// @ts-nocheck
import { GraphQLResolveInfo, SelectionSetNode, FieldNode, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
import { gql } from '@graphql-mesh/utils';

import type { GetMeshOptions } from '@graphql-mesh/runtime';
import type { YamlConfig } from '@graphql-mesh/types';
import { defaultImportFn, handleImport } from '@graphql-mesh/utils';
import { PubSub } from '@graphql-mesh/utils';
import { DefaultLogger } from '@graphql-mesh/utils';
import type { MeshResolvedSource } from '@graphql-mesh/runtime';
import type { MeshTransform, MeshPlugin } from '@graphql-mesh/types';
import { parse } from 'graphql';
import { createMeshHTTPHandler, MeshHTTPHandler } from '@graphql-mesh/http';
import { getMesh, type ExecuteMeshFn, type SubscribeMeshFn, type MeshContext as BaseMeshContext, type MeshInstance } from '@graphql-mesh/runtime';
import { MeshStore, FsStoreStorageAdapter } from '@graphql-mesh/store';
import { path as pathModule } from '@graphql-mesh/cross-helpers';
import type { ImportFn } from '@graphql-mesh/types';
import type { HashavshevetTypes } from './sources/Hashavshevet/types';
export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
export type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;



/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  /** The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text. */
  String: { input: string; output: string; }
  /** The `Boolean` scalar type represents `true` or `false`. */
  Boolean: { input: boolean; output: boolean; }
  /** The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1. */
  Int: { input: number; output: number; }
  /** The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point). */
  Float: { input: number; output: number; }
  /** The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf). */
  JSON: { input: any; output: any; }
  ObjMap: { input: unknown; output: unknown; }
};

export type Query = {
  getSession?: Maybe<getSessionResponse>;
  getCompanies?: Maybe<getCompaniesResponse>;
  getRecordsRaw?: Maybe<getRecordsResponse>;
  getTransactionsRaw?: Maybe<getTransactionsResponse>;
  getBatchRaw?: Maybe<getBatchResponse>;
  checkBatch?: Maybe<checkBatchResponse>;
  getAccountsRaw?: Maybe<getAccountsResponse>;
  getBankPageRecordsRaw?: Maybe<getBankPageRecordsResponse>;
  getSortCodesRaw?: Maybe<getSortCodesResponse>;
  getSortCodes: Array<SortCode>;
  getAccounts: Array<Account>;
  getRecords: Array<RecordType>;
  getTransactions: Array<Transaction>;
  getBatch?: Maybe<Batch>;
  getBankPageRecords: Array<BankPageRecord>;
};


export type QuerygetRecordsRawArgs = {
  input?: InputMaybe<queryInput_getRecordsRaw_input_Input>;
};


export type QuerygetTransactionsRawArgs = {
  input?: InputMaybe<queryInput_getTransactionsRaw_input_Input>;
};


export type QuerygetBatchRawArgs = {
  input?: InputMaybe<queryInput_getBatchRaw_input_Input>;
};


export type QuerycheckBatchArgs = {
  input?: InputMaybe<queryInput_checkBatch_input_Input>;
};


export type QuerygetAccountsRawArgs = {
  input?: InputMaybe<queryInput_getAccountsRaw_input_Input>;
};


export type QuerygetBankPageRecordsRawArgs = {
  input?: InputMaybe<queryInput_getBankPageRecordsRaw_input_Input>;
};


export type QuerygetSortCodesRawArgs = {
  input?: InputMaybe<queryInput_getSortCodesRaw_input_Input>;
};


export type QuerygetAccountsArgs = {
  input?: InputMaybe<getAccountsInput>;
};


export type QuerygetRecordsArgs = {
  input?: InputMaybe<getRecordsInput>;
};


export type QuerygetTransactionsArgs = {
  input?: InputMaybe<getTransactionsInput>;
};


export type QuerygetBatchArgs = {
  input?: InputMaybe<getBatchInput>;
};


export type QuerygetBankPageRecordsArgs = {
  input?: InputMaybe<getBankPageRecordsInput>;
};

export type getSessionResponse = {
  data: Array<Maybe<Scalars['JSON']['output']>>;
  session: query_getSession_session;
};

export type query_getSession_session = {
  branch?: Maybe<Scalars['Int']['output']>;
  cid?: Maybe<Scalars['String']['output']>;
  company_id?: Maybe<Scalars['Int']['output']>;
  company_name?: Maybe<Scalars['String']['output']>;
  use_name?: Maybe<Scalars['String']['output']>;
  user?: Maybe<Scalars['String']['output']>;
  user_id?: Maybe<Scalars['Int']['output']>;
  wizcomp_no?: Maybe<Scalars['Int']['output']>;
};

export type getCompaniesResponse = {
  status: query_getCompanies_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getCompanies_status = {
  repdata: Array<Maybe<query_getCompanies_status_repdata_items>>;
  errors?: Maybe<query_getCompanies_status_errors>;
};

export type query_getCompanies_status_repdata_items = {
  Comp_Vatnum: Scalars['String']['output'];
  Company_File_Name: Scalars['String']['output'];
  Company_Name: Scalars['String']['output'];
};

export type query_getCompanies_status_errors =
  | 'errors'
  | 'OK';

export type getRecordsResponse = {
  status: query_getRecordsRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getRecordsRaw_status = {
  repdata?: Maybe<Array<Maybe<RecordType>>>;
  errors?: Maybe<query_getRecordsRaw_status_errors>;
};

/** A Single Record */
export type RecordType = {
  /** Main account details identifier */
  accountId?: Maybe<Scalars['String']['output']>;
  /** Batch identifier */
  batchId?: Maybe<Scalars['Int']['output']>;
  /** Counter account identifier */
  counterAccountId?: Maybe<Scalars['String']['output']>;
  /** Counter account name */
  counterAccountName?: Maybe<Scalars['String']['output']>;
  /** Cumulative balance */
  cumulativeBalance?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance by filter */
  cumulativeBalanceByFilter?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance by sorting code */
  cumulativeBalanceBySortKey?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance of total open amount of record */
  cumulativeBalanceOfOpenSumInRecord?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance without opening balance */
  cumulativeBalanceWithoutOpeningBalance?: Maybe<Scalars['Float']['output']>;
  /** Credit / Debit */
  debitOrCredit?: Maybe<Scalars['String']['output']>;
  debitOrCreditNumber?: Maybe<query_getRecordsRaw_status_repdata_items_debitOrCreditNumber>;
  /** Estimated total amount */
  estimatedSum?: Maybe<Scalars['Float']['output']>;
  /** Credit amount in foreign currency */
  foreignCurrencyCredit?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance in foreign currency */
  foreignCurrencyCumulativeBalance?: Maybe<Scalars['Float']['output']>;
  /** Cumulative balance in foreign currency without opening balance */
  foreignCurrencyCumulativeBalanceWithoutOpeningBalance?: Maybe<Scalars['Float']['output']>;
  /** Dedit amount in foreign currency */
  foreignCurrencyDebit?: Maybe<Scalars['Float']['output']>;
  /** Total amount in foreign currency */
  foreignCurrencySum?: Maybe<Scalars['Float']['output']>;
  /** Total amount in foreign currency closed in record */
  foreignCurrencySumClosedInRecord?: Maybe<Scalars['Float']['output']>;
  /** Total amount in foreign currency open  in record */
  foreignCurrencySumOpenInRecord?: Maybe<Scalars['Float']['output']>;
  /** Record identifier */
  id?: Maybe<Scalars['Int']['output']>;
  /** Match number - card analysis */
  matchNumberCardAnalysis?: Maybe<Scalars['Int']['output']>;
  /** Credit amount in NIS */
  shekelCredit?: Maybe<Scalars['Float']['output']>;
  /** Dedit amount in NIS */
  shekelDebit?: Maybe<Scalars['Float']['output']>;
  /** Total NIS amount */
  shekelSum?: Maybe<Scalars['Float']['output']>;
  /** Total NIS amount closed in record */
  shekelSumClosedInRecord?: Maybe<Scalars['Float']['output']>;
  /** Total NIS amount open  in record */
  shekelSumOpenInRecord?: Maybe<Scalars['Float']['output']>;
  /** Transaction identifier */
  transactionId?: Maybe<Scalars['Int']['output']>;
  transaction?: Maybe<Transaction>;
  batch?: Maybe<Batch>;
  account?: Maybe<Account>;
  counterAccount?: Maybe<Account>;
};

/** Credit (-1) / Debit (1) */
export type query_getRecordsRaw_status_repdata_items_debitOrCreditNumber =
  | 'NEGATIVE_1'
  | '_1';

export type query_getRecordsRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getRecordsRaw_input_Input = {
  parameters?: InputMaybe<Array<InputMaybe<Scalars['JSON']['input']>>>;
  datafile?: InputMaybe<Scalars['String']['input']>;
};

export type getTransactionsResponse = {
  status: query_getTransactionsRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getTransactionsRaw_status = {
  repdata?: Maybe<Array<Maybe<Transaction>>>;
  errors?: Maybe<query_getTransactionsRaw_status_errors>;
};

export type Transaction = {
  /** VAT registration number (max [20 or 9?] characters) */
  authorizedDealerNumber?: Maybe<Scalars['String']['output']>;
  /** Batch Identifier */
  batchId?: Maybe<Scalars['Int']['output']>;
  /** Branch */
  branch?: Maybe<Scalars['Int']['output']>;
  /** Branch Name */
  branchName?: Maybe<Scalars['String']['output']>;
  /** Cheque Identifier */
  chequeId?: Maybe<Scalars['Int']['output']>;
  /** Code of cost center (existing code) */
  costingCode?: Maybe<Scalars['String']['output']>;
  /** Cost-center code name */
  costingCodeName?: Maybe<Scalars['String']['output']>;
  /** Cost-center code filter */
  costingCodeFilter?: Maybe<Scalars['String']['output']>;
  /** Main credit account identifier (max 15 charactes) */
  creditorId?: Maybe<Scalars['String']['output']>;
  /** Currency */
  currencyCode?: Maybe<Scalars['String']['output']>;
  /** Additional date */
  date3?: Maybe<Scalars['String']['output']>;
  /** Main debit account identifier (max 15 charactes) */
  debtorId?: Maybe<Scalars['String']['output']>;
  /** Description (max 250 characters) */
  description?: Maybe<Scalars['String']['output']>;
  /** Remarks (max 50 characters) */
  details1?: Maybe<Scalars['String']['output']>;
  /** Additional remarks (max 50 characters) */
  details2?: Maybe<Scalars['String']['output']>;
  /** Due date */
  dueDate?: Maybe<Scalars['String']['output']>;
  /** exchange rate differences */
  exchangeRateDifferences?: Maybe<Scalars['String']['output']>;
  /** Total amount in foreign currency */
  foreignCurrencySum?: Maybe<Scalars['Float']['output']>;
  /** Transaction Identifier */
  id?: Maybe<Scalars['Int']['output']>;
  /** Inventory Identifier */
  inventoryId?: Maybe<Scalars['Int']['output']>;
  /** Linked file */
  linkedFile?: Maybe<Scalars['String']['output']>;
  /** Quantity */
  quantity?: Maybe<Scalars['Float']['output']>;
  /** Reference */
  reference1?: Maybe<Scalars['Int']['output']>;
  /** Reference-2 */
  reference2?: Maybe<Scalars['Int']['output']>;
  /** Referenc-3 */
  reference3?: Maybe<Scalars['Int']['output']>;
  /** Register number */
  registerNumber?: Maybe<Scalars['Int']['output']>;
  /** Total NIS amount */
  shekelSum?: Maybe<Scalars['Float']['output']>;
  /** Identifier of transaction cancelled by Strogno */
  stornoCancelledTransactionId?: Maybe<Scalars['Int']['output']>;
  /** Transaction type code */
  type?: Maybe<Scalars['String']['output']>;
  /** User name */
  userName?: Maybe<Scalars['String']['output']>;
  /** Date */
  valueDate?: Maybe<Scalars['String']['output']>;
  batch?: Maybe<Batch>;
  records?: Maybe<Array<Maybe<RecordType>>>;
  creditor?: Maybe<Account>;
  debtor?: Maybe<Account>;
};

export type query_getTransactionsRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getTransactionsRaw_input_Input = {
  parameters?: InputMaybe<Array<InputMaybe<Scalars['JSON']['input']>>>;
  datafile?: InputMaybe<Scalars['String']['input']>;
};

export type getBatchResponse = {
  status: query_getBatchRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getBatchRaw_status = {
  repdata?: Maybe<Array<Maybe<Batch>>>;
  errors?: Maybe<query_getBatchRaw_status_errors>;
};

/** A Single Batch */
export type Batch = {
  amount?: Maybe<Scalars['Float']['output']>;
  creditAmount?: Maybe<Scalars['Float']['output']>;
  debitAmount?: Maybe<Scalars['Float']['output']>;
  /** Remarks */
  details?: Maybe<Scalars['String']['output']>;
  /** Batch identifier */
  id?: Maybe<Scalars['Int']['output']>;
  /** Initiate date */
  initDate?: Maybe<Scalars['String']['output']>;
  /** Initiate time */
  initTime?: Maybe<Scalars['String']['output']>;
  /** Issue date */
  issueDate?: Maybe<Scalars['String']['output']>;
  /** Status */
  status?: Maybe<Scalars['String']['output']>;
  /** Type */
  type?: Maybe<Scalars['String']['output']>;
  transactions?: Maybe<Array<Maybe<Transaction>>>;
};

export type query_getBatchRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getBatchRaw_input_Input = {
  parameters?: InputMaybe<Array<InputMaybe<Scalars['JSON']['input']>>>;
  datafile?: InputMaybe<Scalars['String']['input']>;
};

export type checkBatchResponse = {
  batch_check?: Maybe<Array<Maybe<BatchCheckResponse>>>;
};

export type BatchCheckResponse = String_container | query_checkBatch_batch_check_oneOf_1_items;

export type String_container = {
  String?: Maybe<Scalars['String']['output']>;
};

export type query_checkBatch_batch_check_oneOf_1_items = {
  /** Transaction identifier. AKA transactionId */
  headerID?: Maybe<Scalars['String']['output']>;
  /** Error code */
  err?: Maybe<Scalars['Int']['output']>;
  /** Record identifier. AKA recordId */
  recId?: Maybe<Scalars['Int']['output']>;
  /** Field name where error occurred */
  field?: Maybe<Scalars['String']['output']>;
  /** Error message */
  TxtMsg?: Maybe<Scalars['String']['output']>;
};

export type queryInput_checkBatch_input_Input = {
  /** Batch identifier */
  batchNo?: InputMaybe<Scalars['Int']['input']>;
};

export type getAccountsResponse = {
  status: query_getAccountsRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getAccountsRaw_status = {
  repdata?: Maybe<Array<Maybe<Account>>>;
  errors?: Maybe<query_getAccountsRaw_status_errors>;
};

/** A Single Account */
export type Account = {
  /** Accounting Code */
  accountingCode?: Maybe<Scalars['Int']['output']>;
  /** Address (max 50 characters) */
  address?: Maybe<Scalars['String']['output']>;
  /** Code for the balance and profit and loss report */
  balanceCode?: Maybe<Scalars['String']['output']>;
  /** Cellphone */
  cellphone?: Maybe<Scalars['String']['output']>;
  /** City (max 20 characters) */
  city?: Maybe<Scalars['String']['output']>;
  /** Code of cost center (existing code) */
  costingCode?: Maybe<Scalars['String']['output']>;
  /** Country (max 20 characters) */
  country?: Maybe<Scalars['String']['output']>;
  /** Email */
  email?: Maybe<Scalars['String']['output']>;
  /** Fax (max 30 characters) */
  fax?: Maybe<Scalars['String']['output']>;
  /** Filtering (5 characters) */
  filter?: Maybe<Scalars['String']['output']>;
  /** Account identifier (max 15 characters) */
  id?: Maybe<Scalars['String']['output']>;
  /** Account identifier (max 15 characters) */
  idOrCompanyNum?: Maybe<Scalars['String']['output']>;
  /** Opening date of the account */
  initDate?: Maybe<Scalars['String']['output']>;
  /** Code of the main account */
  mainAccount?: Maybe<Scalars['String']['output']>;
  /** Main account code */
  mainAccountCode?: Maybe<Scalars['Int']['output']>;
  /** Account name (max 50 characters) */
  name?: Maybe<Scalars['String']['output']>;
  /** Phone (max 30 characters) */
  phone?: Maybe<Scalars['String']['output']>;
  /** Postal code */
  postalCode?: Maybe<Scalars['String']['output']>;
  /** Remarks (max 50 characters) */
  remarks?: Maybe<Scalars['String']['output']>;
  /** Sorting code ID */
  sortCodeId?: Maybe<Scalars['Int']['output']>;
  /** Sorting code name */
  sortCodeName?: Maybe<Scalars['String']['output']>;
  /** website address */
  website?: Maybe<Scalars['String']['output']>;
  sortCode?: Maybe<SortCode>;
};

export type query_getAccountsRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getAccountsRaw_input_Input = {
  parameters?: InputMaybe<Array<InputMaybe<Scalars['JSON']['input']>>>;
  datafile?: InputMaybe<Scalars['String']['input']>;
};

export type getBankPageRecordsResponse = {
  status: query_getBankPageRecordsRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getBankPageRecordsRaw_status = {
  repdata?: Maybe<Array<Maybe<BankPageRecord>>>;
  errors?: Maybe<query_getBankPageRecordsRaw_status_errors>;
};

/** A Single Bank Page Record */
export type BankPageRecord = {
  /** Account identifier */
  accountId?: Maybe<Scalars['String']['output']>;
  /** Account name (max 50 characters) */
  accountName?: Maybe<Scalars['String']['output']>;
  /** Adjusted record */
  adjustedRecord?: Maybe<Scalars['String']['output']>;
  /** Bank page identifier */
  bankPageId?: Maybe<Scalars['Int']['output']>;
  /** Cumulative balance */
  cumulativeBalance?: Maybe<Scalars['Float']['output']>;
  /** Calculated cumulative balance */
  cumulativeBalanceCalculated?: Maybe<Scalars['Float']['output']>;
  /** Date */
  date?: Maybe<Scalars['String']['output']>;
  /** Credit / Debit */
  debitOrCredit?: Maybe<Scalars['String']['output']>;
  /** Remarks (max 50 characters) */
  details?: Maybe<Scalars['String']['output']>;
  /** Bank page record identifier */
  id?: Maybe<Scalars['Int']['output']>;
  /** Match number */
  matchNumber?: Maybe<Scalars['Int']['output']>;
  /** Reference */
  reference?: Maybe<Scalars['Int']['output']>;
  /** Total ammount */
  sum?: Maybe<Scalars['Float']['output']>;
  account?: Maybe<Account>;
};

export type query_getBankPageRecordsRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getBankPageRecordsRaw_input_Input = {
  parameters?: InputMaybe<Array<InputMaybe<Scalars['JSON']['input']>>>;
  datafile?: InputMaybe<Scalars['String']['input']>;
};

export type getSortCodesResponse = {
  status: query_getSortCodesRaw_status;
  statusCode?: Maybe<Scalars['Int']['output']>;
};

export type query_getSortCodesRaw_status = {
  repdata?: Maybe<Array<Maybe<SortCode>>>;
  errors?: Maybe<query_getSortCodesRaw_status_errors>;
};

/** A Single Sort Code */
export type SortCode = {
  /** Sorting code */
  code?: Maybe<Scalars['Int']['output']>;
  /** Sorting code name */
  name?: Maybe<Scalars['String']['output']>;
  accounts?: Maybe<Array<Maybe<Account>>>;
};

export type query_getSortCodesRaw_status_errors =
  | 'errors'
  | 'OK';

export type queryInput_getSortCodesRaw_input_Input = {
  parameters: Array<InputMaybe<Scalars['JSON']['input']>>;
  datafile: Scalars['String']['input'];
};

export type Mutation = {
  importTransactionsToBatch?: Maybe<importTransactionsToBatchResponse>;
  createBatch?: Maybe<createBatch>;
  issueBatch?: Maybe<issueBatchResponse>;
  importAccountsRaw?: Maybe<importAccountsResponse>;
  importBankPage?: Maybe<importBankPageResponse>;
  importAccounts?: Maybe<importAccountsResponse>;
};


export type MutationimportTransactionsToBatchArgs = {
  input?: InputMaybe<mutationInput_importTransactionsToBatch_input_Input>;
};


export type MutationissueBatchArgs = {
  input?: InputMaybe<mutationInput_issueBatch_input_Input>;
};


export type MutationimportAccountsRawArgs = {
  input?: InputMaybe<importAccountsRawRequest_Input>;
};


export type MutationimportBankPageArgs = {
  input?: InputMaybe<mutationInput_importBankPage_input_Input>;
};


export type MutationimportAccountsArgs = {
  input?: InputMaybe<importAccountsInput>;
};

/** Response for Posting Transactions to a Batch */
export type importTransactionsToBatchResponse = {
  /** Final Status */
  status?: Maybe<Scalars['String']['output']>;
  /** Batch Issue Status */
  batch_issue?: Maybe<Scalars['String']['output']>;
  batch_check?: Maybe<Array<Maybe<BatchCheckResponse>>>;
  /** Batch identifier (on cases new batch was created) */
  newbatch?: Maybe<Scalars['Int']['output']>;
  /** Batch identifier (on cases added to existing batch) */
  batchno?: Maybe<Scalars['Int']['output']>;
  errors?: Maybe<Array<Maybe<mutation_importTransactionsToBatch_errors>>>;
  batch?: Maybe<Batch>;
};

/** errors list */
export type mutation_importTransactionsToBatch_errors = mutation_importTransactionsToBatch_errors_oneOf_0_items | String_container;

export type mutation_importTransactionsToBatch_errors_oneOf_0_items = {
  /** Transaction identifier. AKA transactionId */
  headerID?: Maybe<Scalars['String']['output']>;
  /** Error code */
  err?: Maybe<Scalars['Int']['output']>;
  /** Record identifier. AKA recordId */
  recId?: Maybe<Scalars['Int']['output']>;
  /** Field name where error occurred */
  field?: Maybe<Scalars['String']['output']>;
  /** Error message */
  TxtMsg?: Maybe<Scalars['String']['output']>;
};

export type mutationInput_importTransactionsToBatch_input_Input = {
  /** Insert the transactions to the temporary batch having this number. If no such temporary batch exists, open a new batch. */
  batchNo?: InputMaybe<Scalars['Int']['input']>;
  /** check the batch for errors and return the batch status */
  check?: InputMaybe<Scalars['Boolean']['input']>;
  /** Insert the transactions to the last open temporary batch. If false, open a new batch. */
  insertolastb?: InputMaybe<Scalars['Boolean']['input']>;
  /** input the temporary batch into the permanent storage. */
  issue?: InputMaybe<Scalars['Boolean']['input']>;
  rows?: InputMaybe<Array<InputMaybe<mutationInput_importTransactionsToBatch_input_rows_items_Input>>>;
};

/** Interface for posting new Transaction */
export type mutationInput_importTransactionsToBatch_input_rows_items_Input = {
  /** VAT registration number (max [20 or 9?] characters) */
  Osek874?: InputMaybe<Scalars['String']['input']>;
  /** Branch */
  Branch?: InputMaybe<Scalars['Int']['input']>;
  /** Code of cost center (existing code) */
  CostCode?: InputMaybe<Scalars['String']['input']>;
  /** Main credit account identifier (max 15 charactes) */
  TransCredID?: InputMaybe<Scalars['String']['input']>;
  /** Name of the main credit account (max 50 characters) */
  CredName?: InputMaybe<Scalars['String']['input']>;
  /** Currency (max 5 characters) */
  CurrencyCode?: InputMaybe<Scalars['String']['input']>;
  /** Additional date */
  DatF3?: InputMaybe<Scalars['String']['input']>;
  /** Main debit account identifier (max 15 charactes) */
  TransDebID?: InputMaybe<Scalars['String']['input']>;
  /** Name of the main debit account (max 50 characters) */
  DebName?: InputMaybe<Scalars['String']['input']>;
  /** Description (max 250 characters) */
  Description?: InputMaybe<Scalars['String']['input']>;
  /** Remarks (max 50 characters) */
  Details?: InputMaybe<Scalars['String']['input']>;
  /** Additional remarks (max 50 characters) */
  Det2?: InputMaybe<Scalars['String']['input']>;
  /** Due date */
  DueDate?: InputMaybe<Scalars['String']['input']>;
  /** Total amount in foreign currency */
  SuFDlr?: InputMaybe<Scalars['Float']['input']>;
  /** Quantity */
  Quant?: InputMaybe<Scalars['Float']['input']>;
  /** Reference */
  Referance?: InputMaybe<Scalars['Int']['input']>;
  /** Reference-2 */
  Ref2?: InputMaybe<Scalars['Int']['input']>;
  /** Reference-3 */
  Ref3?: InputMaybe<Scalars['Int']['input']>;
  /** Total NIS amount (credit or debit) */
  SuF: Scalars['Float']['input'];
  /** Transaction type code */
  TransType?: InputMaybe<Scalars['String']['input']>;
  /** Date */
  ValueDate?: InputMaybe<Scalars['String']['input']>;
  /** List of Records to add. */
  moves?: InputMaybe<Array<InputMaybe<mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input>>>;
};

/** Interface for posting new Record */
export type mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input = {
  /** Account identifier (max 15 characters) */
  AccountKey: Scalars['String']['input'];
  /** Debit=1, Credit=0 */
  DebitCredit: Scalars['Int']['input'];
  /** Foreign currency amount */
  SufDlr?: InputMaybe<Scalars['Float']['input']>;
  /** NIS amount */
  Suf: Scalars['Float']['input'];
};

export type createBatch = {
  newbatch: Scalars['Int']['output'];
};

export type issueBatchResponse = {
  batch_check?: Maybe<Array<Maybe<BatchCheckResponse>>>;
  /** Batch issue status */
  batch_issue?: Maybe<Scalars['String']['output']>;
};

export type mutationInput_issueBatch_input_Input = {
  /** Batch identifier */
  batchNo?: InputMaybe<Scalars['Int']['input']>;
};

export type importAccountsResponse = {
  status: mutation_importAccountsRaw_status;
  errors: Array<Maybe<mutation_importAccountsRaw_errors_items>>;
};

export type mutation_importAccountsRaw_status =
  | 'errors'
  | 'OK';

export type mutation_importAccountsRaw_errors_items = {
  /** Index */
  index: Scalars['Int']['output'];
  /** Field name where error occurred */
  field?: Maybe<Scalars['String']['output']>;
  /** Error description */
  err?: Maybe<Scalars['String']['output']>;
};

export type importAccountsRawRequest_Input = {
  /** Allow inserting new records. If false only update is allowed */
  insertnew: Scalars['Boolean']['input'];
  rows: Array<InputMaybe<AccountImport_Input>>;
  myindex?: InputMaybe<acc_const>;
};

/** A Single Account for Import */
export type AccountImport_Input = {
  /** [id] Account identifier (max 15 characters) */
  AccountKey: Scalars['String']['input'];
  /** [address] Address (max 50 characters) */
  Address?: InputMaybe<Scalars['String']['input']>;
  /** [agent] Salesperson */
  Agent?: InputMaybe<Scalars['Int']['input']>;
  /** [centralAccount], Central account key (existing account) (max 15 characters) */
  AssignKey?: InputMaybe<Scalars['String']['input']>;
  /** Average supply time */
  AverageSupplyPeriod?: InputMaybe<Scalars['Float']['input']>;
  /** Average delay of payments */
  AvgLatePay?: InputMaybe<Scalars['Float']['input']>;
  /** [balanceCode] Code for the balance and profit and loss report */
  BalanceCode?: InputMaybe<Scalars['String']['input']>;
  /** [bankAccountId] Bank account # (max 20 characters) */
  BankAccount?: InputMaybe<Scalars['String']['input']>;
  /** [bankId] Bank code (max 3 characters) */
  BankCode?: InputMaybe<Scalars['String']['input']>;
  /** [bankBranchId] Bank branch code (max 5 characters) */
  BranchCode?: InputMaybe<Scalars['String']['input']>;
  /** [city] City (max 20 characters) */
  City?: InputMaybe<Scalars['String']['input']>;
  /** [costingCode] Code of cost center (existing code) */
  CostCode?: InputMaybe<Scalars['String']['input']>;
  /** [country] Country (max 20 characters) */
  Country?: InputMaybe<Scalars['String']['input']>;
  /** Split payment code */
  CreditTermsCode?: InputMaybe<Scalars['Float']['input']>;
  /** Message for the customer (max 250 characters) */
  CustomerNote?: InputMaybe<Scalars['String']['input']>;
  /** [incomeFileNumber] Income file number (max 20 characters) */
  DeductFile?: InputMaybe<Scalars['String']['input']>;
  /** [withholdingPercent] % withholding tax */
  DeductionPrc?: InputMaybe<Scalars['Float']['input']>;
  /** [withholdingValidity] Validity date of the % withholding tax */
  DeductionValid?: InputMaybe<Scalars['String']['input']>;
  /** [details] Remarks (max 50 characters) */
  Details?: InputMaybe<Scalars['String']['input']>;
  /** Account key for small differences (existing account) (max 15 characters) */
  DifferAcc?: InputMaybe<Scalars['String']['input']>;
  /** Discount code */
  DiscountCode?: InputMaybe<Scalars['Float']['input']>;
  /** Default value for foreign currency (max 5 characters) */
  DocCurr?: InputMaybe<Scalars['String']['input']>;
  /** [email] Email */
  Email?: InputMaybe<Scalars['String']['input']>;
  /** [fax] Fax (max 30 characters) */
  Fax?: InputMaybe<Scalars['String']['input']>;
  /** [filter] Filtering (5 characters) */
  Filter?: InputMaybe<Scalars['String']['input']>;
  /** Fix cost of order */
  FixedOrderCost?: InputMaybe<Scalars['Float']['input']>;
  /** [name] Account name (max 50 characters) */
  FullName?: InputMaybe<Scalars['String']['input']>;
  /** [mainAccount] Code of the main account */
  MainAccount?: InputMaybe<Scalars['String']['input']>;
  Masav?: InputMaybe<mutationInput_importAccountsRaw_input_rows_items_Masav>;
  /** Currency for reconciliation (when the price is in foreign currency) (max 5 characters) */
  MatchCurr?: InputMaybe<Scalars['String']['input']>;
  /** [maxCredit] Credit limit */
  MaxCredit?: InputMaybe<Scalars['Float']['input']>;
  /** [maxCreditCurrency] Credit currency (max 5 characters) */
  MaxCreditCurrency?: InputMaybe<Scalars['String']['input']>;
  /** [maxObligo] Credit risk limit */
  MaxObligo?: InputMaybe<Scalars['Float']['input']>;
  /** [maxObligoCurrency] Credit risk currency (max 5 characters) */
  MaxObligoCurrency?: InputMaybe<Scalars['String']['input']>;
  /** [phone] Phone (max 30 characters) */
  Phone?: InputMaybe<Scalars['String']['input']>;
  /** [sortGroup] Sorting code */
  SortGroup?: InputMaybe<Scalars['Int']['input']>;
  /** [authorizedDealerNumber] VAT registration number (max [20 or 9?] characters) */
  TaxFileNum?: InputMaybe<Scalars['String']['input']>;
  /** [generalDiscountPercent] % customer discount */
  TFtalDiscount?: InputMaybe<Scalars['Float']['input']>;
  /** [vatExempt] VAT exempt, 1/0 */
  VatExampt?: InputMaybe<Scalars['String']['input']>;
  /** Web site (max 250 characters) */
  WebSite?: InputMaybe<Scalars['String']['input']>;
  /** [occupation] Occupation (max 15 characters) */
  WorF?: InputMaybe<Scalars['String']['input']>;
  /** [zipcode] Zip code (max 10 characters) */
  Zip?: InputMaybe<Scalars['String']['input']>;
};

/** Transfer to MASAV. 0/1 */
export type mutationInput_importAccountsRaw_input_rows_items_Masav =
  | '_0'
  | '_1';

export type acc_const =
  | 'acc';

export type importBankPageResponse = {
  status: mutation_importBankPage_status;
  errors: Array<Maybe<mutation_importBankPage_errors_items>>;
};

export type mutation_importBankPage_status =
  | 'errors'
  | 'OK';

export type mutation_importBankPage_errors_items = {
  /** Index */
  index: Scalars['Int']['output'];
  /** Field name where error occurred */
  field?: Maybe<Scalars['String']['output']>;
  /** Error description */
  err?: Maybe<Scalars['String']['output']>;
};

export type mutationInput_importBankPage_input_Input = {
  rows: Array<InputMaybe<mutationInput_importBankPage_input_rows_items_Input>>;
};

export type mutationInput_importBankPage_input_rows_items_Input = {
  /** Account identifier (max 15 characters) */
  AccountKey: Scalars['String']['input'];
  CreditDebit: mutationInput_importBankPage_input_rows_items_CreditDebit;
  /** Date */
  DatF: Scalars['String']['input'];
  /** Remarks (max 50 characters) */
  Details?: InputMaybe<Scalars['String']['input']>;
  /** Reference */
  Reference?: InputMaybe<Scalars['Int']['input']>;
  /** NIS amount */
  SuF: Scalars['Float']['input'];
};

/** Debit=1, Credit=0 */
export type mutationInput_importBankPage_input_rows_items_CreditDebit =
  | '_0'
  | '_1';

export type HTTPMethod =
  | 'GET'
  | 'HEAD'
  | 'POST'
  | 'PUT'
  | 'DELETE'
  | 'CONNECT'
  | 'OPTIONS'
  | 'TRACE'
  | 'PATCH';

export type getAccountsInput = {
  idMin?: InputMaybe<Scalars['String']['input']>;
  idMax?: InputMaybe<Scalars['String']['input']>;
  sortCodeMin?: InputMaybe<Scalars['Int']['input']>;
  sortCodeMax?: InputMaybe<Scalars['Int']['input']>;
  nameMin?: InputMaybe<Scalars['String']['input']>;
  nameMax?: InputMaybe<Scalars['String']['input']>;
};

export type getRecordsInput = {
  idMin?: InputMaybe<Scalars['Int']['input']>;
  idMax?: InputMaybe<Scalars['Int']['input']>;
  transactionIdMin?: InputMaybe<Scalars['Float']['input']>;
  transactionIdMax?: InputMaybe<Scalars['Float']['input']>;
  accountIdMin?: InputMaybe<Scalars['String']['input']>;
  accountIdMax?: InputMaybe<Scalars['String']['input']>;
  ounterAccountIdMin?: InputMaybe<Scalars['String']['input']>;
  ounterAccountIdMax?: InputMaybe<Scalars['String']['input']>;
  debitOrCreditNumberMin?: InputMaybe<Scalars['Float']['input']>;
  debitOrCreditNumberMax?: InputMaybe<Scalars['Float']['input']>;
};

export type getTransactionsInput = {
  batchIdMin?: InputMaybe<Scalars['Int']['input']>;
  batchIdMax?: InputMaybe<Scalars['Int']['input']>;
  creditorIdMin?: InputMaybe<Scalars['String']['input']>;
  creditorIdMax?: InputMaybe<Scalars['String']['input']>;
  debtorIdMin?: InputMaybe<Scalars['String']['input']>;
  debtorIdMax?: InputMaybe<Scalars['String']['input']>;
  dueDateMin?: InputMaybe<Scalars['String']['input']>;
  dueDateMax?: InputMaybe<Scalars['String']['input']>;
  idMin?: InputMaybe<Scalars['Int']['input']>;
  idMax?: InputMaybe<Scalars['Int']['input']>;
  shekelSumMin?: InputMaybe<Scalars['Float']['input']>;
  shekelSumMax?: InputMaybe<Scalars['Float']['input']>;
  valueDateMin?: InputMaybe<Scalars['String']['input']>;
  valueDateMax?: InputMaybe<Scalars['String']['input']>;
};

export type getBatchInput = {
  idMin?: InputMaybe<Scalars['Int']['input']>;
  idMax?: InputMaybe<Scalars['Int']['input']>;
  statusMin?: InputMaybe<Scalars['String']['input']>;
  statusMax?: InputMaybe<Scalars['String']['input']>;
  initDateMin?: InputMaybe<Scalars['String']['input']>;
  initDateMax?: InputMaybe<Scalars['String']['input']>;
};

export type getBankPageRecordsInput = {
  idMin?: InputMaybe<Scalars['Int']['input']>;
  idMax?: InputMaybe<Scalars['Int']['input']>;
  bankPageIdMin?: InputMaybe<Scalars['Int']['input']>;
  bankPageIdMax?: InputMaybe<Scalars['Int']['input']>;
  dateMin?: InputMaybe<Scalars['String']['input']>;
  dateMax?: InputMaybe<Scalars['String']['input']>;
};

export type importAccountsInput = {
  /** Allow inserting new records. If false only update is allowed */
  insertnew: Scalars['Boolean']['input'];
  rows: Array<InputMaybe<AccountImport_Input>>;
};

export type WithIndex<TObject> = TObject & Record<string, any>;
export type ResolversObject<TObject> = WithIndex<TObject>;

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


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

export type LegacyStitchingResolver<TResult, TParent, TContext, TArgs> = {
  fragment: string;
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};

export type NewStitchingResolver<TResult, TParent, TContext, TArgs> = {
  selectionSet: string | ((fieldNode: FieldNode) => SelectionSetNode);
  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
};
export type StitchingResolver<TResult, TParent, TContext, TArgs> = LegacyStitchingResolver<TResult, TParent, TContext, TArgs> | NewStitchingResolver<TResult, TParent, TContext, TArgs>;
export type Resolver<TResult, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> =
  | ResolverFn<TResult, TParent, TContext, TArgs>
  | ResolverWithResolve<TResult, TParent, TContext, TArgs>
  | StitchingResolver<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 = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> =
  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;

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

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

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

export type DirectiveResolverFn<TResult = Record<PropertyKey, never>, TParent = Record<PropertyKey, never>, TContext = Record<PropertyKey, never>, TArgs = Record<PropertyKey, never>> = (
  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>> = ResolversObject<{
  BatchCheckResponse:
    | ( String_container )
    | ( query_checkBatch_batch_check_oneOf_1_items )
  ;
  mutation_importTransactionsToBatch_errors:
    | ( mutation_importTransactionsToBatch_errors_oneOf_0_items )
    | ( String_container )
  ;
}>;


/** Mapping between all available schema types and the resolvers types */
export type ResolversTypes = ResolversObject<{
  Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
  getSessionResponse: ResolverTypeWrapper<getSessionResponse>;
  JSON: ResolverTypeWrapper<Scalars['JSON']['output']>;
  query_getSession_session: ResolverTypeWrapper<query_getSession_session>;
  Int: ResolverTypeWrapper<Scalars['Int']['output']>;
  getCompaniesResponse: ResolverTypeWrapper<getCompaniesResponse>;
  query_getCompanies_status: ResolverTypeWrapper<query_getCompanies_status>;
  query_getCompanies_status_repdata_items: ResolverTypeWrapper<query_getCompanies_status_repdata_items>;
  query_getCompanies_status_errors: query_getCompanies_status_errors;
  getRecordsResponse: ResolverTypeWrapper<getRecordsResponse>;
  query_getRecordsRaw_status: ResolverTypeWrapper<query_getRecordsRaw_status>;
  RecordType: ResolverTypeWrapper<RecordType>;
  Float: ResolverTypeWrapper<Scalars['Float']['output']>;
  query_getRecordsRaw_status_repdata_items_debitOrCreditNumber: null;
  query_getRecordsRaw_status_errors: query_getRecordsRaw_status_errors;
  queryInput_getRecordsRaw_input_Input: queryInput_getRecordsRaw_input_Input;
  getTransactionsResponse: ResolverTypeWrapper<getTransactionsResponse>;
  query_getTransactionsRaw_status: ResolverTypeWrapper<query_getTransactionsRaw_status>;
  Transaction: ResolverTypeWrapper<Transaction>;
  query_getTransactionsRaw_status_errors: query_getTransactionsRaw_status_errors;
  queryInput_getTransactionsRaw_input_Input: queryInput_getTransactionsRaw_input_Input;
  getBatchResponse: ResolverTypeWrapper<getBatchResponse>;
  query_getBatchRaw_status: ResolverTypeWrapper<query_getBatchRaw_status>;
  Batch: ResolverTypeWrapper<Batch>;
  query_getBatchRaw_status_errors: query_getBatchRaw_status_errors;
  queryInput_getBatchRaw_input_Input: queryInput_getBatchRaw_input_Input;
  checkBatchResponse: ResolverTypeWrapper<Omit<checkBatchResponse, 'batch_check'> & { batch_check?: Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>> }>;
  BatchCheckResponse: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['BatchCheckResponse']>;
  String_container: ResolverTypeWrapper<String_container>;
  query_checkBatch_batch_check_oneOf_1_items: ResolverTypeWrapper<query_checkBatch_batch_check_oneOf_1_items>;
  queryInput_checkBatch_input_Input: queryInput_checkBatch_input_Input;
  getAccountsResponse: ResolverTypeWrapper<getAccountsResponse>;
  query_getAccountsRaw_status: ResolverTypeWrapper<query_getAccountsRaw_status>;
  Account: ResolverTypeWrapper<Account>;
  query_getAccountsRaw_status_errors: query_getAccountsRaw_status_errors;
  queryInput_getAccountsRaw_input_Input: queryInput_getAccountsRaw_input_Input;
  getBankPageRecordsResponse: ResolverTypeWrapper<getBankPageRecordsResponse>;
  query_getBankPageRecordsRaw_status: ResolverTypeWrapper<query_getBankPageRecordsRaw_status>;
  BankPageRecord: ResolverTypeWrapper<BankPageRecord>;
  query_getBankPageRecordsRaw_status_errors: query_getBankPageRecordsRaw_status_errors;
  queryInput_getBankPageRecordsRaw_input_Input: queryInput_getBankPageRecordsRaw_input_Input;
  getSortCodesResponse: ResolverTypeWrapper<getSortCodesResponse>;
  query_getSortCodesRaw_status: ResolverTypeWrapper<query_getSortCodesRaw_status>;
  SortCode: ResolverTypeWrapper<SortCode>;
  query_getSortCodesRaw_status_errors: query_getSortCodesRaw_status_errors;
  queryInput_getSortCodesRaw_input_Input: queryInput_getSortCodesRaw_input_Input;
  Mutation: ResolverTypeWrapper<Record<PropertyKey, never>>;
  importTransactionsToBatchResponse: ResolverTypeWrapper<Omit<importTransactionsToBatchResponse, 'batch_check' | 'errors'> & { batch_check?: Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>>, errors?: Maybe<Array<Maybe<ResolversTypes['mutation_importTransactionsToBatch_errors']>>> }>;
  mutation_importTransactionsToBatch_errors: ResolverTypeWrapper<ResolversUnionTypes<ResolversTypes>['mutation_importTransactionsToBatch_errors']>;
  mutation_importTransactionsToBatch_errors_oneOf_0_items: ResolverTypeWrapper<mutation_importTransactionsToBatch_errors_oneOf_0_items>;
  mutationInput_importTransactionsToBatch_input_Input: mutationInput_importTransactionsToBatch_input_Input;
  mutationInput_importTransactionsToBatch_input_rows_items_Input: mutationInput_importTransactionsToBatch_input_rows_items_Input;
  mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input: mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input;
  createBatch: ResolverTypeWrapper<createBatch>;
  issueBatchResponse: ResolverTypeWrapper<Omit<issueBatchResponse, 'batch_check'> & { batch_check?: Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>> }>;
  mutationInput_issueBatch_input_Input: mutationInput_issueBatch_input_Input;
  importAccountsResponse: ResolverTypeWrapper<importAccountsResponse>;
  mutation_importAccountsRaw_status: mutation_importAccountsRaw_status;
  mutation_importAccountsRaw_errors_items: ResolverTypeWrapper<mutation_importAccountsRaw_errors_items>;
  importAccountsRawRequest_Input: importAccountsRawRequest_Input;
  AccountImport_Input: AccountImport_Input;
  mutationInput_importAccountsRaw_input_rows_items_Masav: null;
  acc_const: acc_const;
  importBankPageResponse: ResolverTypeWrapper<importBankPageResponse>;
  mutation_importBankPage_status: mutation_importBankPage_status;
  mutation_importBankPage_errors_items: ResolverTypeWrapper<mutation_importBankPage_errors_items>;
  mutationInput_importBankPage_input_Input: mutationInput_importBankPage_input_Input;
  mutationInput_importBankPage_input_rows_items_Input: mutationInput_importBankPage_input_rows_items_Input;
  mutationInput_importBankPage_input_rows_items_CreditDebit: null;
  ObjMap: ResolverTypeWrapper<Scalars['ObjMap']['output']>;
  HTTPMethod: HTTPMethod;
  String: ResolverTypeWrapper<Scalars['String']['output']>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
  getAccountsInput: getAccountsInput;
  getRecordsInput: getRecordsInput;
  getTransactionsInput: getTransactionsInput;
  getBatchInput: getBatchInput;
  getBankPageRecordsInput: getBankPageRecordsInput;
  importAccountsInput: importAccountsInput;
}>;

/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = ResolversObject<{
  Query: Record<PropertyKey, never>;
  getSessionResponse: getSessionResponse;
  JSON: Scalars['JSON']['output'];
  query_getSession_session: query_getSession_session;
  Int: Scalars['Int']['output'];
  getCompaniesResponse: getCompaniesResponse;
  query_getCompanies_status: query_getCompanies_status;
  query_getCompanies_status_repdata_items: query_getCompanies_status_repdata_items;
  getRecordsResponse: getRecordsResponse;
  query_getRecordsRaw_status: query_getRecordsRaw_status;
  RecordType: RecordType;
  Float: Scalars['Float']['output'];
  queryInput_getRecordsRaw_input_Input: queryInput_getRecordsRaw_input_Input;
  getTransactionsResponse: getTransactionsResponse;
  query_getTransactionsRaw_status: query_getTransactionsRaw_status;
  Transaction: Transaction;
  queryInput_getTransactionsRaw_input_Input: queryInput_getTransactionsRaw_input_Input;
  getBatchResponse: getBatchResponse;
  query_getBatchRaw_status: query_getBatchRaw_status;
  Batch: Batch;
  queryInput_getBatchRaw_input_Input: queryInput_getBatchRaw_input_Input;
  checkBatchResponse: Omit<checkBatchResponse, 'batch_check'> & { batch_check?: Maybe<Array<Maybe<ResolversParentTypes['BatchCheckResponse']>>> };
  BatchCheckResponse: ResolversUnionTypes<ResolversParentTypes>['BatchCheckResponse'];
  String_container: String_container;
  query_checkBatch_batch_check_oneOf_1_items: query_checkBatch_batch_check_oneOf_1_items;
  queryInput_checkBatch_input_Input: queryInput_checkBatch_input_Input;
  getAccountsResponse: getAccountsResponse;
  query_getAccountsRaw_status: query_getAccountsRaw_status;
  Account: Account;
  queryInput_getAccountsRaw_input_Input: queryInput_getAccountsRaw_input_Input;
  getBankPageRecordsResponse: getBankPageRecordsResponse;
  query_getBankPageRecordsRaw_status: query_getBankPageRecordsRaw_status;
  BankPageRecord: BankPageRecord;
  queryInput_getBankPageRecordsRaw_input_Input: queryInput_getBankPageRecordsRaw_input_Input;
  getSortCodesResponse: getSortCodesResponse;
  query_getSortCodesRaw_status: query_getSortCodesRaw_status;
  SortCode: SortCode;
  queryInput_getSortCodesRaw_input_Input: queryInput_getSortCodesRaw_input_Input;
  Mutation: Record<PropertyKey, never>;
  importTransactionsToBatchResponse: Omit<importTransactionsToBatchResponse, 'batch_check' | 'errors'> & { batch_check?: Maybe<Array<Maybe<ResolversParentTypes['BatchCheckResponse']>>>, errors?: Maybe<Array<Maybe<ResolversParentTypes['mutation_importTransactionsToBatch_errors']>>> };
  mutation_importTransactionsToBatch_errors: ResolversUnionTypes<ResolversParentTypes>['mutation_importTransactionsToBatch_errors'];
  mutation_importTransactionsToBatch_errors_oneOf_0_items: mutation_importTransactionsToBatch_errors_oneOf_0_items;
  mutationInput_importTransactionsToBatch_input_Input: mutationInput_importTransactionsToBatch_input_Input;
  mutationInput_importTransactionsToBatch_input_rows_items_Input: mutationInput_importTransactionsToBatch_input_rows_items_Input;
  mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input: mutationInput_importTransactionsToBatch_input_rows_items_moves_items_Input;
  createBatch: createBatch;
  issueBatchResponse: Omit<issueBatchResponse, 'batch_check'> & { batch_check?: Maybe<Array<Maybe<ResolversParentTypes['BatchCheckResponse']>>> };
  mutationInput_issueBatch_input_Input: mutationInput_issueBatch_input_Input;
  importAccountsResponse: importAccountsResponse;
  mutation_importAccountsRaw_errors_items: mutation_importAccountsRaw_errors_items;
  importAccountsRawRequest_Input: importAccountsRawRequest_Input;
  AccountImport_Input: AccountImport_Input;
  importBankPageResponse: importBankPageResponse;
  mutation_importBankPage_errors_items: mutation_importBankPage_errors_items;
  mutationInput_importBankPage_input_Input: mutationInput_importBankPage_input_Input;
  mutationInput_importBankPage_input_rows_items_Input: mutationInput_importBankPage_input_rows_items_Input;
  ObjMap: Scalars['ObjMap']['output'];
  String: Scalars['String']['output'];
  Boolean: Scalars['Boolean']['output'];
  getAccountsInput: getAccountsInput;
  getRecordsInput: getRecordsInput;
  getTransactionsInput: getTransactionsInput;
  getBatchInput: getBatchInput;
  getBankPageRecordsInput: getBankPageRecordsInput;
  importAccountsInput: importAccountsInput;
}>;

export type enumDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
  value?: Maybe<Scalars['String']['input']>;
};

export type enumDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = enumDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type resolveRootDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
};

export type resolveRootDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = resolveRootDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type typescriptDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
  type?: Maybe<Scalars['String']['input']>;
};

export type typescriptDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = typescriptDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type exampleDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
  value?: Maybe<Scalars['ObjMap']['input']>;
};

export type exampleDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = exampleDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type httpOperationDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
  path?: Maybe<Scalars['String']['input']>;
  operationSpecificHeaders?: Maybe<Array<Maybe<Array<Maybe<Scalars['String']['input']>>>>>;
  httpMethod?: Maybe<HTTPMethod>;
  isBinary?: Maybe<Scalars['Boolean']['input']>;
  requestBaseBody?: Maybe<Scalars['ObjMap']['input']>;
  queryParamArgMap?: Maybe<Scalars['ObjMap']['input']>;
  queryStringOptionsByParam?: Maybe<Scalars['ObjMap']['input']>;
  jsonApiFields?: Maybe<Scalars['Boolean']['input']>;
  queryStringOptions?: Maybe<Scalars['ObjMap']['input']>;
};

export type httpOperationDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = httpOperationDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type transportDirectiveArgs = {
  subgraph?: Maybe<Scalars['String']['input']>;
  kind?: Maybe<Scalars['String']['input']>;
  location?: Maybe<Scalars['String']['input']>;
  headers?: Maybe<Array<Maybe<Array<Maybe<Scalars['String']['input']>>>>>;
  queryStringOptions?: Maybe<Scalars['ObjMap']['input']>;
  queryParams?: Maybe<Array<Maybe<Array<Maybe<Scalars['String']['input']>>>>>;
};

export type transportDirectiveResolver<Result, Parent, ContextType = MeshContext, Args = transportDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;

export type QueryResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
  getSession?: Resolver<Maybe<ResolversTypes['getSessionResponse']>, ParentType, ContextType>;
  getCompanies?: Resolver<Maybe<ResolversTypes['getCompaniesResponse']>, ParentType, ContextType>;
  getRecordsRaw?: Resolver<Maybe<ResolversTypes['getRecordsResponse']>, ParentType, ContextType, Partial<QuerygetRecordsRawArgs>>;
  getTransactionsRaw?: Resolver<Maybe<ResolversTypes['getTransactionsResponse']>, ParentType, ContextType, Partial<QuerygetTransactionsRawArgs>>;
  getBatchRaw?: Resolver<Maybe<ResolversTypes['getBatchResponse']>, ParentType, ContextType, Partial<QuerygetBatchRawArgs>>;
  checkBatch?: Resolver<Maybe<ResolversTypes['checkBatchResponse']>, ParentType, ContextType, Partial<QuerycheckBatchArgs>>;
  getAccountsRaw?: Resolver<Maybe<ResolversTypes['getAccountsResponse']>, ParentType, ContextType, Partial<QuerygetAccountsRawArgs>>;
  getBankPageRecordsRaw?: Resolver<Maybe<ResolversTypes['getBankPageRecordsResponse']>, ParentType, ContextType, Partial<QuerygetBankPageRecordsRawArgs>>;
  getSortCodesRaw?: Resolver<Maybe<ResolversTypes['getSortCodesResponse']>, ParentType, ContextType, Partial<QuerygetSortCodesRawArgs>>;
  getSortCodes?: Resolver<Array<ResolversTypes['SortCode']>, ParentType, ContextType>;
  getAccounts?: Resolver<Array<ResolversTypes['Account']>, ParentType, ContextType, Partial<QuerygetAccountsArgs>>;
  getRecords?: Resolver<Array<ResolversTypes['RecordType']>, ParentType, ContextType, Partial<QuerygetRecordsArgs>>;
  getTransactions?: Resolver<Array<ResolversTypes['Transaction']>, ParentType, ContextType, Partial<QuerygetTransactionsArgs>>;
  getBatch?: Resolver<Maybe<ResolversTypes['Batch']>, ParentType, ContextType, Partial<QuerygetBatchArgs>>;
  getBankPageRecords?: Resolver<Array<ResolversTypes['BankPageRecord']>, ParentType, ContextType, Partial<QuerygetBankPageRecordsArgs>>;
}>;

export type getSessionResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getSessionResponse'] = ResolversParentTypes['getSessionResponse']> = ResolversObject<{
  data?: Resolver<Array<Maybe<ResolversTypes['JSON']>>, ParentType, ContextType>;
  session?: Resolver<ResolversTypes['query_getSession_session'], ParentType, ContextType>;
}>;

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

export type query_getSession_sessionResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getSession_session'] = ResolversParentTypes['query_getSession_session']> = ResolversObject<{
  branch?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  cid?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  company_id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  company_name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  use_name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  user?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  user_id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  wizcomp_no?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type getCompaniesResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getCompaniesResponse'] = ResolversParentTypes['getCompaniesResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getCompanies_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getCompanies_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getCompanies_status'] = ResolversParentTypes['query_getCompanies_status']> = ResolversObject<{
  repdata?: Resolver<Array<Maybe<ResolversTypes['query_getCompanies_status_repdata_items']>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getCompanies_status_errors']>, ParentType, ContextType>;
}>;

export type query_getCompanies_status_repdata_itemsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getCompanies_status_repdata_items'] = ResolversParentTypes['query_getCompanies_status_repdata_items']> = ResolversObject<{
  Comp_Vatnum?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  Company_File_Name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  Company_Name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
}>;

export type getRecordsResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getRecordsResponse'] = ResolversParentTypes['getRecordsResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getRecordsRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getRecordsRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getRecordsRaw_status'] = ResolversParentTypes['query_getRecordsRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['RecordType']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getRecordsRaw_status_errors']>, ParentType, ContextType>;
}>;

export type RecordTypeResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['RecordType'] = ResolversParentTypes['RecordType']> = ResolversObject<{
  accountId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  batchId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  counterAccountId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  counterAccountName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  cumulativeBalance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  cumulativeBalanceByFilter?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  cumulativeBalanceBySortKey?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  cumulativeBalanceOfOpenSumInRecord?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  cumulativeBalanceWithoutOpeningBalance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  debitOrCredit?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  debitOrCreditNumber?: Resolver<Maybe<ResolversTypes['query_getRecordsRaw_status_repdata_items_debitOrCreditNumber']>, ParentType, ContextType>;
  estimatedSum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencyCredit?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencyCumulativeBalance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencyCumulativeBalanceWithoutOpeningBalance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencyDebit?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencySum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencySumClosedInRecord?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  foreignCurrencySumOpenInRecord?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  matchNumberCardAnalysis?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  shekelCredit?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  shekelDebit?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  shekelSum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  shekelSumClosedInRecord?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  shekelSumOpenInRecord?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  transactionId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  transaction?: Resolver<Maybe<ResolversTypes['Transaction']>, ParentType, ContextType>;
  batch?: Resolver<Maybe<ResolversTypes['Batch']>, ParentType, ContextType>;
  account?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType>;
  counterAccount?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType>;
}>;

export type query_getRecordsRaw_status_repdata_items_debitOrCreditNumberResolvers = { NEGATIVE_1: -1, _1: 1 };

export type getTransactionsResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getTransactionsResponse'] = ResolversParentTypes['getTransactionsResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getTransactionsRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getTransactionsRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getTransactionsRaw_status'] = ResolversParentTypes['query_getTransactionsRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['Transaction']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getTransactionsRaw_status_errors']>, ParentType, ContextType>;
}>;

export type TransactionResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Transaction'] = ResolversParentTypes['Transaction']> = ResolversObject<{
  authorizedDealerNumber?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  batchId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  branch?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  branchName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  chequeId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  costingCode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  costingCodeName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  costingCodeFilter?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  creditorId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  currencyCode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  date3?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  debtorId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  description?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  details1?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  details2?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  dueDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  exchangeRateDifferences?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  foreignCurrencySum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  inventoryId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  linkedFile?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  quantity?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  reference1?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  reference2?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  reference3?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  registerNumber?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  shekelSum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  stornoCancelledTransactionId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  type?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  userName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  valueDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  batch?: Resolver<Maybe<ResolversTypes['Batch']>, ParentType, ContextType>;
  records?: Resolver<Maybe<Array<Maybe<ResolversTypes['RecordType']>>>, ParentType, ContextType>;
  creditor?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType>;
  debtor?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType>;
}>;

export type getBatchResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getBatchResponse'] = ResolversParentTypes['getBatchResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getBatchRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getBatchRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getBatchRaw_status'] = ResolversParentTypes['query_getBatchRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['Batch']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getBatchRaw_status_errors']>, ParentType, ContextType>;
}>;

export type BatchResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Batch'] = ResolversParentTypes['Batch']> = ResolversObject<{
  amount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  creditAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  debitAmount?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  details?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  initDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  initTime?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  issueDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  status?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  type?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  transactions?: Resolver<Maybe<Array<Maybe<ResolversTypes['Transaction']>>>, ParentType, ContextType>;
}>;

export type checkBatchResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['checkBatchResponse'] = ResolversParentTypes['checkBatchResponse']> = ResolversObject<{
  batch_check?: Resolver<Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>>, ParentType, ContextType>;
}>;

export type BatchCheckResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['BatchCheckResponse'] = ResolversParentTypes['BatchCheckResponse']> = ResolversObject<{
  __resolveType: TypeResolveFn<'String_container' | 'query_checkBatch_batch_check_oneOf_1_items', ParentType, ContextType>;
}>;

export type String_containerResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['String_container'] = ResolversParentTypes['String_container']> = ResolversObject<{
  String?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

export type query_checkBatch_batch_check_oneOf_1_itemsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_checkBatch_batch_check_oneOf_1_items'] = ResolversParentTypes['query_checkBatch_batch_check_oneOf_1_items']> = ResolversObject<{
  headerID?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  err?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  recId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  field?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  TxtMsg?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

export type getAccountsResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getAccountsResponse'] = ResolversParentTypes['getAccountsResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getAccountsRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getAccountsRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getAccountsRaw_status'] = ResolversParentTypes['query_getAccountsRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['Account']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getAccountsRaw_status_errors']>, ParentType, ContextType>;
}>;

export type AccountResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Account'] = ResolversParentTypes['Account']> = ResolversObject<{
  accountingCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  address?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  balanceCode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  cellphone?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  city?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  costingCode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  country?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  email?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  fax?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  filter?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  idOrCompanyNum?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  initDate?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  mainAccount?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  mainAccountCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  phone?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  postalCode?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  remarks?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sortCodeId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  sortCodeName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  website?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  sortCode?: Resolver<Maybe<ResolversTypes['SortCode']>, ParentType, ContextType>;
}>;

export type getBankPageRecordsResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getBankPageRecordsResponse'] = ResolversParentTypes['getBankPageRecordsResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getBankPageRecordsRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getBankPageRecordsRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getBankPageRecordsRaw_status'] = ResolversParentTypes['query_getBankPageRecordsRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['BankPageRecord']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getBankPageRecordsRaw_status_errors']>, ParentType, ContextType>;
}>;

export type BankPageRecordResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['BankPageRecord'] = ResolversParentTypes['BankPageRecord']> = ResolversObject<{
  accountId?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  accountName?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  adjustedRecord?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  bankPageId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  cumulativeBalance?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  cumulativeBalanceCalculated?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  date?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  debitOrCredit?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  details?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  matchNumber?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  reference?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  sum?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  account?: Resolver<Maybe<ResolversTypes['Account']>, ParentType, ContextType>;
}>;

export type getSortCodesResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getSortCodesResponse'] = ResolversParentTypes['getSortCodesResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['query_getSortCodesRaw_status'], ParentType, ContextType>;
  statusCode?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
}>;

export type query_getSortCodesRaw_statusResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['query_getSortCodesRaw_status'] = ResolversParentTypes['query_getSortCodesRaw_status']> = ResolversObject<{
  repdata?: Resolver<Maybe<Array<Maybe<ResolversTypes['SortCode']>>>, ParentType, ContextType>;
  errors?: Resolver<Maybe<ResolversTypes['query_getSortCodesRaw_status_errors']>, ParentType, ContextType>;
}>;

export type SortCodeResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['SortCode'] = ResolversParentTypes['SortCode']> = ResolversObject<{
  code?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  accounts?: Resolver<Maybe<Array<Maybe<ResolversTypes['Account']>>>, ParentType, ContextType>;
}>;

export type MutationResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Mutation'] = ResolversParentTypes['Mutation']> = ResolversObject<{
  importTransactionsToBatch?: Resolver<Maybe<ResolversTypes['importTransactionsToBatchResponse']>, ParentType, ContextType, Partial<MutationimportTransactionsToBatchArgs>>;
  createBatch?: Resolver<Maybe<ResolversTypes['createBatch']>, ParentType, ContextType>;
  issueBatch?: Resolver<Maybe<ResolversTypes['issueBatchResponse']>, ParentType, ContextType, Partial<MutationissueBatchArgs>>;
  importAccountsRaw?: Resolver<Maybe<ResolversTypes['importAccountsResponse']>, ParentType, ContextType, Partial<MutationimportAccountsRawArgs>>;
  importBankPage?: Resolver<Maybe<ResolversTypes['importBankPageResponse']>, ParentType, ContextType, Partial<MutationimportBankPageArgs>>;
  importAccounts?: Resolver<Maybe<ResolversTypes['importAccountsResponse']>, ParentType, ContextType, Partial<MutationimportAccountsArgs>>;
}>;

export type importTransactionsToBatchResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['importTransactionsToBatchResponse'] = ResolversParentTypes['importTransactionsToBatchResponse']> = ResolversObject<{
  status?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  batch_issue?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  batch_check?: Resolver<Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>>, ParentType, ContextType>;
  newbatch?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  batchno?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  errors?: Resolver<Maybe<Array<Maybe<ResolversTypes['mutation_importTransactionsToBatch_errors']>>>, ParentType, ContextType>;
  batch?: Resolver<Maybe<ResolversTypes['Batch']>, ParentType, ContextType>;
}>;

export type mutation_importTransactionsToBatch_errorsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['mutation_importTransactionsToBatch_errors'] = ResolversParentTypes['mutation_importTransactionsToBatch_errors']> = ResolversObject<{
  __resolveType: TypeResolveFn<'mutation_importTransactionsToBatch_errors_oneOf_0_items' | 'String_container', ParentType, ContextType>;
}>;

export type mutation_importTransactionsToBatch_errors_oneOf_0_itemsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['mutation_importTransactionsToBatch_errors_oneOf_0_items'] = ResolversParentTypes['mutation_importTransactionsToBatch_errors_oneOf_0_items']> = ResolversObject<{
  headerID?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  err?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  recId?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  field?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  TxtMsg?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
}>;

export type createBatchResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['createBatch'] = ResolversParentTypes['createBatch']> = ResolversObject<{
  newbatch?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
}>;

export type issueBatchResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['issueBatchResponse'] = ResolversParentTypes['issueBatchResponse']> = ResolversObject<{
  batch_check?: Resolver<Maybe<Array<Maybe<ResolversTypes['BatchCheckResponse']>>>, ParentType, ContextType>;
  batch_issue?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
}>;

export type importAccountsResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['importAccountsResponse'] = ResolversParentTypes['importAccountsResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['mutation_importAccountsRaw_status'], ParentType, ContextType>;
  errors?: Resolver<Array<Maybe<ResolversTypes['mutation_importAccountsRaw_errors_items']>>, ParentType, ContextType>;
}>;

export type mutation_importAccountsRaw_errors_itemsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['mutation_importAccountsRaw_errors_items'] = ResolversParentTypes['mutation_importAccountsRaw_errors_items']> = ResolversObject<{
  index?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  field?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  err?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
}>;

export type mutationInput_importAccountsRaw_input_rows_items_MasavResolvers = { _0: '0', _1: '1' };

export type importBankPageResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['importBankPageResponse'] = ResolversParentTypes['importBankPageResponse']> = ResolversObject<{
  status?: Resolver<ResolversTypes['mutation_importBankPage_status'], ParentType, ContextType>;
  errors?: Resolver<Array<Maybe<ResolversTypes['mutation_importBankPage_errors_items']>>, ParentType, ContextType>;
}>;

export type mutation_importBankPage_errors_itemsResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['mutation_importBankPage_errors_items'] = ResolversParentTypes['mutation_importBankPage_errors_items']> = ResolversObject<{
  index?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  field?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  err?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
}>;

export type mutationInput_importBankPage_input_rows_items_CreditDebitResolvers = { _0: '0', _1: '1' };

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

export type Resolvers<ContextType = MeshContext> = ResolversObject<{
  Query?: QueryResolvers<ContextType>;
  getSessionResponse?: getSessionResponseResolvers<ContextType>;
  JSON?: GraphQLScalarType;
  query_getSession_session?: query_getSession_sessionResolvers<ContextType>;
  getCompaniesResponse?: getCompaniesResponseResolvers<ContextType>;
  query_getCompanies_status?: query_getCompanies_statusResolvers<ContextType>;
  query_getCompanies_status_repdata_items?: query_getCompanies_status_repdata_itemsResolvers<ContextType>;
  getRecordsResponse?: getRecordsResponseResolvers<ContextType>;
  query_getRecordsRaw_status?: query_getRecordsRaw_statusResolvers<ContextType>;
  RecordType?: RecordTypeResolvers<ContextType>;
  query_getRecordsRaw_status_repdata_items_debitOrCreditNumber?: query_getRecordsRaw_status_repdata_items_debitOrCreditNumberResolvers;
  getTransactionsResponse?: getTransactionsResponseResolvers<ContextType>;
  query_getTransactionsRaw_status?: query_getTransactionsRaw_statusResolvers<ContextType>;
  Transaction?: TransactionResolvers<ContextType>;
  getBatchResponse?: getBatchResponseResolvers<ContextType>;
  query_getBatchRaw_status?: query_getBatchRaw_statusResolvers<ContextType>;
  Batch?: BatchResolvers<ContextType>;
  checkBatchResponse?: checkBatchResponseResolvers<ContextType>;
  BatchCheckResponse?: BatchCheckResponseResolvers<ContextType>;
  String_container?: String_containerResolvers<ContextType>;
  query_checkBatch_batch_check_oneOf_1_items?: query_checkBatch_batch_check_oneOf_1_itemsResolvers<ContextType>;
  getAccountsResponse?: getAccountsResponseResolvers<ContextType>;
  query_getAccountsRaw_status?: query_getAccountsRaw_statusResolvers<ContextType>;
  Account?: AccountResolvers<ContextType>;
  getBankPageRecordsResponse?: getBankPageRecordsResponseResolvers<ContextType>;
  query_getBankPageRecordsRaw_status?: query_getBankPageRecordsRaw_statusResolvers<ContextType>;
  BankPageRecord?: BankPageRecordResolvers<ContextType>;
  getSortCodesResponse?: getSortCodesResponseResolvers<ContextType>;
  query_getSortCodesRaw_status?: query_getSortCodesRaw_statusResolvers<ContextType>;
  SortCode?: SortCodeResolvers<ContextType>;
  Mutation?: MutationResolvers<ContextType>;
  importTransactionsToBatchResponse?: importTransactionsToBatchResponseResolvers<ContextType>;
  mutation_importTransactionsToBatch_errors?: mutation_importTransactionsToBatch_errorsResolvers<ContextType>;
  mutation_importTransactionsToBatch_errors_oneOf_0_items?: mutation_importTransactionsToBatch_errors_oneOf_0_itemsResolvers<ContextType>;
  createBatch?: createBatchResolvers<ContextType>;
  issueBatchResponse?: issueBatchResponseResolvers<ContextType>;
  importAccountsResponse?: importAccountsResponseResolvers<ContextType>;
  mutation_importAccountsRaw_errors_items?: mutation_importAccountsRaw_errors_itemsResolvers<ContextType>;
  mutationInput_importAccountsRaw_input_rows_items_Masav?: mutationInput_importAccountsRaw_input_rows_items_MasavResolvers;
  importBankPageResponse?: importBankPageResponseResolvers<ContextType>;
  mutation_importBankPage_errors_items?: mutation_importBankPage_errors_itemsResolvers<ContextType>;
  mutationInput_importBankPage_input_rows_items_CreditDebit?: mutationInput_importBankPage_input_rows_items_CreditDebitResolvers;
  ObjMap?: GraphQLScalarType;
}>;

export type DirectiveResolvers<ContextType = MeshContext> = ResolversObject<{
  enum?: enumDirectiveResolver<any, any, ContextType>;
  resolveRoot?: resolveRootDirectiveResolver<any, any, ContextType>;
  typescript?: typescriptDirectiveResolver<any, any, ContextType>;
  example?: exampleDirectiveResolver<any, any, ContextType>;
  httpOperation?: httpOperationDirectiveResolver<any, any, ContextType>;
  transport?: transportDirectiveResolver<any, any, ContextType>;
}>;

export type MeshInContextSDK = HashavshevetTypes.Context;

export type MeshContext = BaseMeshContext & MeshInContextSDK;


const baseDir = pathModule.join(typeof __dirname === 'string' ? __dirname : '/', '..');

const importFn: ImportFn = <T>(moduleId: string) => {
  const relativeModuleId = (pathModule.isAbsolute(moduleId) ? pathModule.relative(baseDir, moduleId) : moduleId).split('\\').join('/').replace(baseDir + '/', '');
  switch(relativeModuleId) {
    case "mesh-artifacts/sources/Hashavshevet/schemaWithAnnotations.js":
      return import("./sources/Hashavshevet/schemaWithAnnotations.js") as T;
    
    default:
      return Promise.reject(new Error(`Cannot find module '${relativeModuleId}'.`));
  }
};

const rootStore = new MeshStore('mesh-artifacts', new FsStoreStorageAdapter({
  cwd: baseDir,
  importFn,
  fileType: "js",
}), {
  readonly: true,
  validate: false
});

export const rawServeConfig: YamlConfig.Config['serve'] = {"browser":false} as any
export async function getMeshOptions(): Promise<GetMeshOptions> {
const pubsub = new PubSub();
const sourcesStore = rootStore.child('sources');
const logger = new DefaultLogger("");
const MeshCache = await import("@graphql-mesh/cache-localforage").then(handleImport);
  const cache = new MeshCache({
      ...{},
      importFn,
      store: rootStore.child('cache'),
      pubsub,
      logger,
    })
const fetchFn = await import('@whatwg-node/fetch').then(m => m?.fetch || m);
const sources: MeshResolvedSource[] = [];
const transforms: MeshTransform[] = [];
const additionalEnvelopPlugins: MeshPlugin<any>[] = [];
const hashavshevetTransforms = [];
const HashavshevetHandler = await import("@graphql-mesh/json-schema").then(handleImport);
const hashavshevetHandler = new HashavshevetHandler({
              name: "Hashavshevet",
              config: {"endpoint":"https://{context.hashavshevetUrl}/","queryStringOptions":{"indices":true},"operationHeaders":{"Authorization":"Bearer {context.authToken}","host":"{context.hashavshevetUrl}","Content-Type":"application/x-www-form-urlencoded","Accept":"application/json"},"operations":[{"type":"Query","field":"getSession","path":"/api/napi","method":"POST","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getSessionResponse"},{"type":"Query","field":"getCompanies","path":"/CompanyListToTokenApi/TokenCompanies","method":"POST","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getCompaniesResponse"},{"type":"Query","field":"getRecordsRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getRecordsRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getRecordsResponse"},{"type":"Query","field":"getTransactionsRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getTransactionsRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getTransactionsResponse"},{"type":"Mutation","field":"importTransactionsToBatch","path":"/jtransApi/tmpBatch","method":"POST","requestSchema":"../json-schemas/importTransactionsToBatchRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/importTransactionsToBatchResponse"},{"type":"Mutation","field":"createBatch","path":"/jtransApi/newBatch","method":"POST","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/createBatch"},{"type":"Query","field":"getBatchRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getBatchRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getBatchResponse"},{"type":"Query","field":"checkBatch","path":"/jtransApi/chkBatch","method":"POST","requestSchema":"../json-schemas/checkBatchRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/checkBatchResponse"},{"type":"Mutation","field":"issueBatch","path":"/jtransApi/issueBatch","method":"POST","requestSchema":"../json-schemas/issueBatchRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/issueBatchResponse"},{"type":"Query","field":"getAccountsRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getAccountsRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getAccountsResponse"},{"type":"Mutation","field":"importAccountsRaw","path":"/IndexApi/importIndex","method":"POST","requestSchema":"../json-schemas/hashavshevetSchema.json#/definitions/importAccountsRawRequest","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/importAccountsResponse"},{"type":"Query","field":"getBankPageRecordsRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getBankPageRecordsRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getBankPageRecordsResponse"},{"type":"Mutation","field":"importBankPage","path":"/BankPagesApi/importBankPage","method":"POST","requestSchema":"../json-schemas/importBankPageRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/importBankPageResponse"},{"type":"Query","field":"getSortCodesRaw","path":"/ExportDataApi/exportData","method":"POST","requestSchema":"../json-schemas/getSortCodesRawRequest.json","responseSchema":"../json-schemas/hashavshevetSchema.json#/definitions/getSortCodesResponse"}]},
              baseDir,
              cache,
              pubsub,
              store: sourcesStore.child("Hashavshevet"),
              logger: logger.child({ source: "Hashavshevet" }),
              importFn,
            });
sources[0] = {
          name: 'Hashavshevet',
          handler: hashavshevetHandler,
          transforms: hashavshevetTransforms
        }
const additionalTypeDefs = [parse("extend type Query {\n  getSortCodes: [SortCode!]!\n  getAccounts(input: getAccountsInput): [Account!]!\n  getRecords(input: getRecordsInput): [RecordType!]!\n  getTransactions(input: getTransactionsInput): [Transaction!]!\n  getBatch(input: getBatchInput): Batch\n  getBankPageRecords(input: getBankPageRecordsInput): [BankPageRecord!]!\n}\n\nextend type Mutation {\n  importAccounts(input: importAccountsInput): importAccountsResponse\n}\n\nextend type Transaction {\n  batch: Batch\n  records: [RecordType]\n  creditor: Account\n  debtor: Account\n}\n\nextend type Batch {\n  transactions: [Transaction]\n}\n\nextend type RecordType {\n  transaction: Transaction\n  batch: Batch\n  account: Account\n  counterAccount: Account\n}\n\nextend type BankPageRecord {\n  account: Account\n}\n\nextend type importTransactionsToBatchResponse {\n  batch: Batch\n}\n\nextend type SortCode {\n  accounts: [Account]\n}\n\nextend type Account {\n  sortCode: SortCode\n}\n\ninput getAccountsInput {\n  idMin: String\n  idMax: String\n  sortCodeMin: Int\n  sortCodeMax: Int\n  nameMin: String\n  nameMax: String\n}\n\ninput getRecordsInput {\n  idMin: Int\n  idMax: Int\n  transactionIdMin: Float\n  transactionIdMax: Float\n  accountIdMin: String\n  accountIdMax: String\n  ounterAccountIdMin: String\n  ounterAccountIdMax: String\n  debitOrCreditNumberMin: Float\n  debitOrCreditNumberMax: Float\n}\n\ninput getTransactionsInput {\n  batchIdMin: Int\n  batchIdMax: Int\n  creditorIdMin: String\n  creditorIdMax: String\n  debtorIdMin: String\n  debtorIdMax: String\n  dueDateMin: String\n  dueDateMax: String\n  idMin: Int\n  idMax: Int\n  shekelSumMin: Float\n  shekelSumMax: Float\n  valueDateMin: String\n  valueDateMax: String\n}\n\ninput getBatchInput {\n  idMin: Int\n  idMax: Int\n  statusMin: String\n  statusMax: String\n  initDateMin: String\n  initDateMax: String\n}\n\ninput getBankPageRecordsInput {\n  idMin: Int\n  idMax: Int\n  bankPageIdMin: Int\n  bankPageIdMax: Int\n  dateMin: String\n  dateMax: String\n}\n\ninput importAccountsInput {\n  \"Allow inserting new records. If false only update is allowed\"\n  insertnew: Boolean!\n  rows: [AccountImport_Input]!\n}"),] as any[];
const additionalResolvers = await Promise.all([
        import("../resolvers/mesh-resolvers.js")
            .then(m => m.resolvers || m.default || m)
      ]);
const Merger = await import("@graphql-mesh/merger-bare").then(handleImport);
const merger = new Merger({
        cache,
        pubsub,
        logger: logger.child({ merger: "bare" }),
        store: rootStore.child("bare")
      })

  return {
    sources,
    transforms,
    additionalTypeDefs,
    additionalResolvers,
    cache,
    pubsub,
    merger,
    logger,
    additionalEnvelopPlugins,
    get documents() {
      return [
      
    ];
    },
    fetchFn,
  };
}

export function createBuiltMeshHTTPHandler<TServerContext = {}>(): MeshHTTPHandler<TServerContext> {
  return createMeshHTTPHandler<TServerContext>({
    baseDir,
    getBuiltMesh: getBuiltMesh,
    rawServeConfig: {"browser":false},
  })
}


let meshInstance$: Promise<MeshInstance> | undefined;

export const pollingInterval = null;

export function getBuiltMesh(): Promise<MeshInstance> {
  if (meshInstance$ == null) {
    if (pollingInterval) {
      setInterval(() => {
        getMeshOptions()
        .then(meshOptions => getMesh(meshOptions))
        .then(newMesh =>
          meshInstance$.then(oldMesh => {
            oldMesh.destroy()
            meshInstance$ = Promise.resolve(newMesh)
          })
        ).catch(err => {
          console.error("Mesh polling failed so the existing version will be used:", err);
        });
      }, pollingInterval)
    }
    meshInstance$ = getMeshOptions().then(meshOptions => getMesh(meshOptions)).then(mesh => {
      const id = mesh.pubsub.subscribe('destroy', () => {
        meshInstance$ = undefined;
        mesh.pubsub.unsubscribe(id);
      });
      return mesh;
    }).catch((err) => {
      meshInstance$ = undefined;
      return Promise.reject(err);
    });
  }
  return meshInstance$;
}

export const execute: ExecuteMeshFn = (...args) => getBuiltMesh().then(({ execute }) => execute(...args));

export const subscribe: SubscribeMeshFn = (...args) => getBuiltMesh().then(({ subscribe }) => subscribe(...args));
export function getMeshSDK<TGlobalContext = any, TOperationContext = any>(globalContext?: TGlobalContext) {
  const sdkRequester$ = getBuiltMesh().then(({ sdkRequesterFactory }) => sdkRequesterFactory(globalContext));
  return getSdk<TOperationContext, TGlobalContext>((...args) => sdkRequester$.then(sdkRequester => sdkRequester(...args)));
}
export type getSession_queryQueryVariables = Exact<{ [key: string]: never; }>;


export type getSession_queryQuery = { getSession?: Maybe<(
    Pick<getSessionResponse, 'data'>
    & { session: Pick<
        query_getSession_session,
        | 'branch'
        | 'cid'
        | 'company_id'
        | 'company_name'
        | 'use_name'
        | 'user'
        | 'user_id'
        | 'wizcomp_no'
      > }
  )> };

export type getCompanies_queryQueryVariables = Exact<{ [key: string]: never; }>;


export type getCompanies_queryQuery = { getCompanies?: Maybe<(
    Pick<getCompaniesResponse, 'statusCode'>
    & { status: (
      Pick<query_getCompanies_status, 'errors'>
      & { repdata: Array<Maybe<Pick<query_getCompanies_status_repdata_items, 'Comp_Vatnum' | 'Company_File_Name' | 'Company_Name'>>> }
    ) }
  )> };

export type getRecordsRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getRecordsRaw_input_Input>;
}>;


export type getRecordsRaw_queryQuery = { getRecordsRaw?: Maybe<(
    Pick<getRecordsResponse, 'statusCode'>
    & { status: (
      Pick<query_getRecordsRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<
          RecordType,
          | 'accountId'
          | 'batchId'
          | 'counterAccountId'
          | 'counterAccountName'
          | 'cumulativeBalance'
          | 'cumulativeBalanceByFilter'
          | 'cumulativeBalanceBySortKey'
          | 'cumulativeBalanceOfOpenSumInRecord'
          | 'cumulativeBalanceWithoutOpeningBalance'
          | 'debitOrCredit'
          | 'debitOrCreditNumber'
          | 'estimatedSum'
          | 'foreignCurrencyCredit'
          | 'foreignCurrencyCumulativeBalance'
          | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
          | 'foreignCurrencyDebit'
          | 'foreignCurrencySum'
          | 'foreignCurrencySumClosedInRecord'
          | 'foreignCurrencySumOpenInRecord'
          | 'id'
          | 'matchNumberCardAnalysis'
          | 'shekelCredit'
          | 'shekelDebit'
          | 'shekelSum'
          | 'shekelSumClosedInRecord'
          | 'shekelSumOpenInRecord'
          | 'transactionId'
        >
        & {
          transaction?: Maybe<(
            Pick<
              Transaction,
              | 'authorizedDealerNumber'
              | 'batchId'
              | 'branch'
              | 'branchName'
              | 'chequeId'
              | 'costingCode'
              | 'costingCodeName'
              | 'costingCodeFilter'
              | 'creditorId'
              | 'currencyCode'
              | 'date3'
              | 'debtorId'
              | 'description'
              | 'details1'
              | 'details2'
              | 'dueDate'
              | 'exchangeRateDifferences'
              | 'foreignCurrencySum'
              | 'id'
              | 'inventoryId'
              | 'linkedFile'
              | 'quantity'
              | 'reference1'
              | 'reference2'
              | 'reference3'
              | 'registerNumber'
              | 'shekelSum'
              | 'stornoCancelledTransactionId'
              | 'type'
              | 'userName'
              | 'valueDate'
            >
            & {
              batch?: Maybe<Pick<
                  Batch,
                  | 'amount'
                  | 'creditAmount'
                  | 'debitAmount'
                  | 'details'
                  | 'id'
                  | 'initDate'
                  | 'initTime'
                  | 'issueDate'
                  | 'status'
                  | 'type'
                >>,
              creditor?: Maybe<Pick<
                  Account,
                  | 'accountingCode'
                  | 'address'
                  | 'balanceCode'
                  | 'cellphone'
                  | 'city'
                  | 'costingCode'
                  | 'country'
                  | 'email'
                  | 'fax'
                  | 'filter'
                  | 'id'
                  | 'idOrCompanyNum'
                  | 'initDate'
                  | 'mainAccount'
                  | 'mainAccountCode'
                  | 'name'
                  | 'phone'
                  | 'postalCode'
                  | 'remarks'
                  | 'sortCodeId'
                  | 'sortCodeName'
                  | 'website'
                >>,
              debtor?: Maybe<Pick<
                  Account,
                  | 'accountingCode'
                  | 'address'
                  | 'balanceCode'
                  | 'cellphone'
                  | 'city'
                  | 'costingCode'
                  | 'country'
                  | 'email'
                  | 'fax'
                  | 'filter'
                  | 'id'
                  | 'idOrCompanyNum'
                  | 'initDate'
                  | 'mainAccount'
                  | 'mainAccountCode'
                  | 'name'
                  | 'phone'
                  | 'postalCode'
                  | 'remarks'
                  | 'sortCodeId'
                  | 'sortCodeName'
                  | 'website'
                >>,
            }
          )>,
          batch?: Maybe<(
            Pick<
              Batch,
              | 'amount'
              | 'creditAmount'
              | 'debitAmount'
              | 'details'
              | 'id'
              | 'initDate'
              | 'initTime'
              | 'issueDate'
              | 'status'
              | 'type'
            >
            & { transactions?: Maybe<Array<Maybe<Pick<
                Transaction,
                | 'authorizedDealerNumber'
                | 'batchId'
                | 'branch'
                | 'branchName'
                | 'chequeId'
                | 'costingCode'
                | 'costingCodeName'
                | 'costingCodeFilter'
                | 'creditorId'
                | 'currencyCode'
                | 'date3'
                | 'debtorId'
                | 'description'
                | 'details1'
                | 'details2'
                | 'dueDate'
                | 'exchangeRateDifferences'
                | 'foreignCurrencySum'
                | 'id'
                | 'inventoryId'
                | 'linkedFile'
                | 'quantity'
                | 'reference1'
                | 'reference2'
                | 'reference3'
                | 'registerNumber'
                | 'shekelSum'
                | 'stornoCancelledTransactionId'
                | 'type'
                | 'userName'
                | 'valueDate'
              >>>> }
          )>,
          account?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
          counterAccount?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
        }
      )>>> }
    ) }
  )> };

export type getTransactionsRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getTransactionsRaw_input_Input>;
}>;


export type getTransactionsRaw_queryQuery = { getTransactionsRaw?: Maybe<(
    Pick<getTransactionsResponse, 'statusCode'>
    & { status: (
      Pick<query_getTransactionsRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<
          Transaction,
          | 'authorizedDealerNumber'
          | 'batchId'
          | 'branch'
          | 'branchName'
          | 'chequeId'
          | 'costingCode'
          | 'costingCodeName'
          | 'costingCodeFilter'
          | 'creditorId'
          | 'currencyCode'
          | 'date3'
          | 'debtorId'
          | 'description'
          | 'details1'
          | 'details2'
          | 'dueDate'
          | 'exchangeRateDifferences'
          | 'foreignCurrencySum'
          | 'id'
          | 'inventoryId'
          | 'linkedFile'
          | 'quantity'
          | 'reference1'
          | 'reference2'
          | 'reference3'
          | 'registerNumber'
          | 'shekelSum'
          | 'stornoCancelledTransactionId'
          | 'type'
          | 'userName'
          | 'valueDate'
        >
        & {
          batch?: Maybe<Pick<
              Batch,
              | 'amount'
              | 'creditAmount'
              | 'debitAmount'
              | 'details'
              | 'id'
              | 'initDate'
              | 'initTime'
              | 'issueDate'
              | 'status'
              | 'type'
            >>,
          records?: Maybe<Array<Maybe<(
            Pick<
              RecordType,
              | 'accountId'
              | 'batchId'
              | 'counterAccountId'
              | 'counterAccountName'
              | 'cumulativeBalance'
              | 'cumulativeBalanceByFilter'
              | 'cumulativeBalanceBySortKey'
              | 'cumulativeBalanceOfOpenSumInRecord'
              | 'cumulativeBalanceWithoutOpeningBalance'
              | 'debitOrCredit'
              | 'debitOrCreditNumber'
              | 'estimatedSum'
              | 'foreignCurrencyCredit'
              | 'foreignCurrencyCumulativeBalance'
              | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
              | 'foreignCurrencyDebit'
              | 'foreignCurrencySum'
              | 'foreignCurrencySumClosedInRecord'
              | 'foreignCurrencySumOpenInRecord'
              | 'id'
              | 'matchNumberCardAnalysis'
              | 'shekelCredit'
              | 'shekelDebit'
              | 'shekelSum'
              | 'shekelSumClosedInRecord'
              | 'shekelSumOpenInRecord'
              | 'transactionId'
            >
            & {
              batch?: Maybe<Pick<
                  Batch,
                  | 'amount'
                  | 'creditAmount'
                  | 'debitAmount'
                  | 'details'
                  | 'id'
                  | 'initDate'
                  | 'initTime'
                  | 'issueDate'
                  | 'status'
                  | 'type'
                >>,
              account?: Maybe<Pick<
                  Account,
                  | 'accountingCode'
                  | 'address'
                  | 'balanceCode'
                  | 'cellphone'
                  | 'city'
                  | 'costingCode'
                  | 'country'
                  | 'email'
                  | 'fax'
                  | 'filter'
                  | 'id'
                  | 'idOrCompanyNum'
                  | 'initDate'
                  | 'mainAccount'
                  | 'mainAccountCode'
                  | 'name'
                  | 'phone'
                  | 'postalCode'
                  | 'remarks'
                  | 'sortCodeId'
                  | 'sortCodeName'
                  | 'website'
                >>,
              counterAccount?: Maybe<Pick<
                  Account,
                  | 'accountingCode'
                  | 'address'
                  | 'balanceCode'
                  | 'cellphone'
                  | 'city'
                  | 'costingCode'
                  | 'country'
                  | 'email'
                  | 'fax'
                  | 'filter'
                  | 'id'
                  | 'idOrCompanyNum'
                  | 'initDate'
                  | 'mainAccount'
                  | 'mainAccountCode'
                  | 'name'
                  | 'phone'
                  | 'postalCode'
                  | 'remarks'
                  | 'sortCodeId'
                  | 'sortCodeName'
                  | 'website'
                >>,
            }
          )>>>,
          creditor?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
          debtor?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
        }
      )>>> }
    ) }
  )> };

export type getBatchRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getBatchRaw_input_Input>;
}>;


export type getBatchRaw_queryQuery = { getBatchRaw?: Maybe<(
    Pick<getBatchResponse, 'statusCode'>
    & { status: (
      Pick<query_getBatchRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<
          Batch,
          | 'amount'
          | 'creditAmount'
          | 'debitAmount'
          | 'details'
          | 'id'
          | 'initDate'
          | 'initTime'
          | 'issueDate'
          | 'status'
          | 'type'
        >
        & { transactions?: Maybe<Array<Maybe<(
          Pick<
            Transaction,
            | 'authorizedDealerNumber'
            | 'batchId'
            | 'branch'
            | 'branchName'
            | 'chequeId'
            | 'costingCode'
            | 'costingCodeName'
            | 'costingCodeFilter'
            | 'creditorId'
            | 'currencyCode'
            | 'date3'
            | 'debtorId'
            | 'description'
            | 'details1'
            | 'details2'
            | 'dueDate'
            | 'exchangeRateDifferences'
            | 'foreignCurrencySum'
            | 'id'
            | 'inventoryId'
            | 'linkedFile'
            | 'quantity'
            | 'reference1'
            | 'reference2'
            | 'reference3'
            | 'registerNumber'
            | 'shekelSum'
            | 'stornoCancelledTransactionId'
            | 'type'
            | 'userName'
            | 'valueDate'
          >
          & {
            records?: Maybe<Array<Maybe<Pick<
                RecordType,
                | 'accountId'
                | 'batchId'
                | 'counterAccountId'
                | 'counterAccountName'
                | 'cumulativeBalance'
                | 'cumulativeBalanceByFilter'
                | 'cumulativeBalanceBySortKey'
                | 'cumulativeBalanceOfOpenSumInRecord'
                | 'cumulativeBalanceWithoutOpeningBalance'
                | 'debitOrCredit'
                | 'debitOrCreditNumber'
                | 'estimatedSum'
                | 'foreignCurrencyCredit'
                | 'foreignCurrencyCumulativeBalance'
                | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
                | 'foreignCurrencyDebit'
                | 'foreignCurrencySum'
                | 'foreignCurrencySumClosedInRecord'
                | 'foreignCurrencySumOpenInRecord'
                | 'id'
                | 'matchNumberCardAnalysis'
                | 'shekelCredit'
                | 'shekelDebit'
                | 'shekelSum'
                | 'shekelSumClosedInRecord'
                | 'shekelSumOpenInRecord'
                | 'transactionId'
              >>>>,
            creditor?: Maybe<Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >>,
            debtor?: Maybe<Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >>,
          }
        )>>> }
      )>>> }
    ) }
  )> };

export type checkBatch_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_checkBatch_input_Input>;
}>;


export type checkBatch_queryQuery = { checkBatch?: Maybe<{ batch_check?: Maybe<Array<Maybe<
      | Pick<String_container, 'String'>
      | Pick<
          query_checkBatch_batch_check_oneOf_1_items,
          | 'headerID'
          | 'err'
          | 'recId'
          | 'field'
          | 'TxtMsg'
        >
    >>> }> };

export type getAccountsRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getAccountsRaw_input_Input>;
}>;


export type getAccountsRaw_queryQuery = { getAccountsRaw?: Maybe<(
    Pick<getAccountsResponse, 'statusCode'>
    & { status: (
      Pick<query_getAccountsRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<
          Account,
          | 'accountingCode'
          | 'address'
          | 'balanceCode'
          | 'cellphone'
          | 'city'
          | 'costingCode'
          | 'country'
          | 'email'
          | 'fax'
          | 'filter'
          | 'id'
          | 'idOrCompanyNum'
          | 'initDate'
          | 'mainAccount'
          | 'mainAccountCode'
          | 'name'
          | 'phone'
          | 'postalCode'
          | 'remarks'
          | 'sortCodeId'
          | 'sortCodeName'
          | 'website'
        >
        & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
      )>>> }
    ) }
  )> };

export type getBankPageRecordsRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getBankPageRecordsRaw_input_Input>;
}>;


export type getBankPageRecordsRaw_queryQuery = { getBankPageRecordsRaw?: Maybe<(
    Pick<getBankPageRecordsResponse, 'statusCode'>
    & { status: (
      Pick<query_getBankPageRecordsRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<
          BankPageRecord,
          | 'accountId'
          | 'accountName'
          | 'adjustedRecord'
          | 'bankPageId'
          | 'cumulativeBalance'
          | 'cumulativeBalanceCalculated'
          | 'date'
          | 'debitOrCredit'
          | 'details'
          | 'id'
          | 'matchNumber'
          | 'reference'
          | 'sum'
        >
        & { account?: Maybe<(
          Pick<
            Account,
            | 'accountingCode'
            | 'address'
            | 'balanceCode'
            | 'cellphone'
            | 'city'
            | 'costingCode'
            | 'country'
            | 'email'
            | 'fax'
            | 'filter'
            | 'id'
            | 'idOrCompanyNum'
            | 'initDate'
            | 'mainAccount'
            | 'mainAccountCode'
            | 'name'
            | 'phone'
            | 'postalCode'
            | 'remarks'
            | 'sortCodeId'
            | 'sortCodeName'
            | 'website'
          >
          & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
        )> }
      )>>> }
    ) }
  )> };

export type getSortCodesRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<queryInput_getSortCodesRaw_input_Input>;
}>;


export type getSortCodesRaw_queryQuery = { getSortCodesRaw?: Maybe<(
    Pick<getSortCodesResponse, 'statusCode'>
    & { status: (
      Pick<query_getSortCodesRaw_status, 'errors'>
      & { repdata?: Maybe<Array<Maybe<(
        Pick<SortCode, 'code' | 'name'>
        & { accounts?: Maybe<Array<Maybe<Pick<
            Account,
            | 'accountingCode'
            | 'address'
            | 'balanceCode'
            | 'cellphone'
            | 'city'
            | 'costingCode'
            | 'country'
            | 'email'
            | 'fax'
            | 'filter'
            | 'id'
            | 'idOrCompanyNum'
            | 'initDate'
            | 'mainAccount'
            | 'mainAccountCode'
            | 'name'
            | 'phone'
            | 'postalCode'
            | 'remarks'
            | 'sortCodeId'
            | 'sortCodeName'
            | 'website'
          >>>> }
      )>>> }
    ) }
  )> };

export type getSortCodes_queryQueryVariables = Exact<{ [key: string]: never; }>;


export type getSortCodes_queryQuery = { getSortCodes: Array<(
    Pick<SortCode, 'code' | 'name'>
    & { accounts?: Maybe<Array<Maybe<Pick<
        Account,
        | 'accountingCode'
        | 'address'
        | 'balanceCode'
        | 'cellphone'
        | 'city'
        | 'costingCode'
        | 'country'
        | 'email'
        | 'fax'
        | 'filter'
        | 'id'
        | 'idOrCompanyNum'
        | 'initDate'
        | 'mainAccount'
        | 'mainAccountCode'
        | 'name'
        | 'phone'
        | 'postalCode'
        | 'remarks'
        | 'sortCodeId'
        | 'sortCodeName'
        | 'website'
      >>>> }
  )> };

export type getAccounts_queryQueryVariables = Exact<{
  input?: InputMaybe<getAccountsInput>;
}>;


export type getAccounts_queryQuery = { getAccounts: Array<(
    Pick<
      Account,
      | 'accountingCode'
      | 'address'
      | 'balanceCode'
      | 'cellphone'
      | 'city'
      | 'costingCode'
      | 'country'
      | 'email'
      | 'fax'
      | 'filter'
      | 'id'
      | 'idOrCompanyNum'
      | 'initDate'
      | 'mainAccount'
      | 'mainAccountCode'
      | 'name'
      | 'phone'
      | 'postalCode'
      | 'remarks'
      | 'sortCodeId'
      | 'sortCodeName'
      | 'website'
    >
    & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
  )> };

export type getRecords_queryQueryVariables = Exact<{
  input?: InputMaybe<getRecordsInput>;
}>;


export type getRecords_queryQuery = { getRecords: Array<(
    Pick<
      RecordType,
      | 'accountId'
      | 'batchId'
      | 'counterAccountId'
      | 'counterAccountName'
      | 'cumulativeBalance'
      | 'cumulativeBalanceByFilter'
      | 'cumulativeBalanceBySortKey'
      | 'cumulativeBalanceOfOpenSumInRecord'
      | 'cumulativeBalanceWithoutOpeningBalance'
      | 'debitOrCredit'
      | 'debitOrCreditNumber'
      | 'estimatedSum'
      | 'foreignCurrencyCredit'
      | 'foreignCurrencyCumulativeBalance'
      | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
      | 'foreignCurrencyDebit'
      | 'foreignCurrencySum'
      | 'foreignCurrencySumClosedInRecord'
      | 'foreignCurrencySumOpenInRecord'
      | 'id'
      | 'matchNumberCardAnalysis'
      | 'shekelCredit'
      | 'shekelDebit'
      | 'shekelSum'
      | 'shekelSumClosedInRecord'
      | 'shekelSumOpenInRecord'
      | 'transactionId'
    >
    & {
      transaction?: Maybe<(
        Pick<
          Transaction,
          | 'authorizedDealerNumber'
          | 'batchId'
          | 'branch'
          | 'branchName'
          | 'chequeId'
          | 'costingCode'
          | 'costingCodeName'
          | 'costingCodeFilter'
          | 'creditorId'
          | 'currencyCode'
          | 'date3'
          | 'debtorId'
          | 'description'
          | 'details1'
          | 'details2'
          | 'dueDate'
          | 'exchangeRateDifferences'
          | 'foreignCurrencySum'
          | 'id'
          | 'inventoryId'
          | 'linkedFile'
          | 'quantity'
          | 'reference1'
          | 'reference2'
          | 'reference3'
          | 'registerNumber'
          | 'shekelSum'
          | 'stornoCancelledTransactionId'
          | 'type'
          | 'userName'
          | 'valueDate'
        >
        & {
          batch?: Maybe<Pick<
              Batch,
              | 'amount'
              | 'creditAmount'
              | 'debitAmount'
              | 'details'
              | 'id'
              | 'initDate'
              | 'initTime'
              | 'issueDate'
              | 'status'
              | 'type'
            >>,
          creditor?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
          debtor?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
        }
      )>,
      batch?: Maybe<(
        Pick<
          Batch,
          | 'amount'
          | 'creditAmount'
          | 'debitAmount'
          | 'details'
          | 'id'
          | 'initDate'
          | 'initTime'
          | 'issueDate'
          | 'status'
          | 'type'
        >
        & { transactions?: Maybe<Array<Maybe<(
          Pick<
            Transaction,
            | 'authorizedDealerNumber'
            | 'batchId'
            | 'branch'
            | 'branchName'
            | 'chequeId'
            | 'costingCode'
            | 'costingCodeName'
            | 'costingCodeFilter'
            | 'creditorId'
            | 'currencyCode'
            | 'date3'
            | 'debtorId'
            | 'description'
            | 'details1'
            | 'details2'
            | 'dueDate'
            | 'exchangeRateDifferences'
            | 'foreignCurrencySum'
            | 'id'
            | 'inventoryId'
            | 'linkedFile'
            | 'quantity'
            | 'reference1'
            | 'reference2'
            | 'reference3'
            | 'registerNumber'
            | 'shekelSum'
            | 'stornoCancelledTransactionId'
            | 'type'
            | 'userName'
            | 'valueDate'
          >
          & {
            creditor?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
            debtor?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
          }
        )>>> }
      )>,
      account?: Maybe<(
        Pick<
          Account,
          | 'accountingCode'
          | 'address'
          | 'balanceCode'
          | 'cellphone'
          | 'city'
          | 'costingCode'
          | 'country'
          | 'email'
          | 'fax'
          | 'filter'
          | 'id'
          | 'idOrCompanyNum'
          | 'initDate'
          | 'mainAccount'
          | 'mainAccountCode'
          | 'name'
          | 'phone'
          | 'postalCode'
          | 'remarks'
          | 'sortCodeId'
          | 'sortCodeName'
          | 'website'
        >
        & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
      )>,
      counterAccount?: Maybe<(
        Pick<
          Account,
          | 'accountingCode'
          | 'address'
          | 'balanceCode'
          | 'cellphone'
          | 'city'
          | 'costingCode'
          | 'country'
          | 'email'
          | 'fax'
          | 'filter'
          | 'id'
          | 'idOrCompanyNum'
          | 'initDate'
          | 'mainAccount'
          | 'mainAccountCode'
          | 'name'
          | 'phone'
          | 'postalCode'
          | 'remarks'
          | 'sortCodeId'
          | 'sortCodeName'
          | 'website'
        >
        & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
      )>,
    }
  )> };

export type getTransactions_queryQueryVariables = Exact<{
  input?: InputMaybe<getTransactionsInput>;
}>;


export type getTransactions_queryQuery = { getTransactions: Array<(
    Pick<
      Transaction,
      | 'authorizedDealerNumber'
      | 'batchId'
      | 'branch'
      | 'branchName'
      | 'chequeId'
      | 'costingCode'
      | 'costingCodeName'
      | 'costingCodeFilter'
      | 'creditorId'
      | 'currencyCode'
      | 'date3'
      | 'debtorId'
      | 'description'
      | 'details1'
      | 'details2'
      | 'dueDate'
      | 'exchangeRateDifferences'
      | 'foreignCurrencySum'
      | 'id'
      | 'inventoryId'
      | 'linkedFile'
      | 'quantity'
      | 'reference1'
      | 'reference2'
      | 'reference3'
      | 'registerNumber'
      | 'shekelSum'
      | 'stornoCancelledTransactionId'
      | 'type'
      | 'userName'
      | 'valueDate'
    >
    & {
      batch?: Maybe<Pick<
          Batch,
          | 'amount'
          | 'creditAmount'
          | 'debitAmount'
          | 'details'
          | 'id'
          | 'initDate'
          | 'initTime'
          | 'issueDate'
          | 'status'
          | 'type'
        >>,
      records?: Maybe<Array<Maybe<(
        Pick<
          RecordType,
          | 'accountId'
          | 'batchId'
          | 'counterAccountId'
          | 'counterAccountName'
          | 'cumulativeBalance'
          | 'cumulativeBalanceByFilter'
          | 'cumulativeBalanceBySortKey'
          | 'cumulativeBalanceOfOpenSumInRecord'
          | 'cumulativeBalanceWithoutOpeningBalance'
          | 'debitOrCredit'
          | 'debitOrCreditNumber'
          | 'estimatedSum'
          | 'foreignCurrencyCredit'
          | 'foreignCurrencyCumulativeBalance'
          | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
          | 'foreignCurrencyDebit'
          | 'foreignCurrencySum'
          | 'foreignCurrencySumClosedInRecord'
          | 'foreignCurrencySumOpenInRecord'
          | 'id'
          | 'matchNumberCardAnalysis'
          | 'shekelCredit'
          | 'shekelDebit'
          | 'shekelSum'
          | 'shekelSumClosedInRecord'
          | 'shekelSumOpenInRecord'
          | 'transactionId'
        >
        & {
          batch?: Maybe<Pick<
              Batch,
              | 'amount'
              | 'creditAmount'
              | 'debitAmount'
              | 'details'
              | 'id'
              | 'initDate'
              | 'initTime'
              | 'issueDate'
              | 'status'
              | 'type'
            >>,
          account?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
          counterAccount?: Maybe<(
            Pick<
              Account,
              | 'accountingCode'
              | 'address'
              | 'balanceCode'
              | 'cellphone'
              | 'city'
              | 'costingCode'
              | 'country'
              | 'email'
              | 'fax'
              | 'filter'
              | 'id'
              | 'idOrCompanyNum'
              | 'initDate'
              | 'mainAccount'
              | 'mainAccountCode'
              | 'name'
              | 'phone'
              | 'postalCode'
              | 'remarks'
              | 'sortCodeId'
              | 'sortCodeName'
              | 'website'
            >
            & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
          )>,
        }
      )>>>,
      creditor?: Maybe<(
        Pick<
          Account,
          | 'accountingCode'
          | 'address'
          | 'balanceCode'
          | 'cellphone'
          | 'city'
          | 'costingCode'
          | 'country'
          | 'email'
          | 'fax'
          | 'filter'
          | 'id'
          | 'idOrCompanyNum'
          | 'initDate'
          | 'mainAccount'
          | 'mainAccountCode'
          | 'name'
          | 'phone'
          | 'postalCode'
          | 'remarks'
          | 'sortCodeId'
          | 'sortCodeName'
          | 'website'
        >
        & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
      )>,
      debtor?: Maybe<(
        Pick<
          Account,
          | 'accountingCode'
          | 'address'
          | 'balanceCode'
          | 'cellphone'
          | 'city'
          | 'costingCode'
          | 'country'
          | 'email'
          | 'fax'
          | 'filter'
          | 'id'
          | 'idOrCompanyNum'
          | 'initDate'
          | 'mainAccount'
          | 'mainAccountCode'
          | 'name'
          | 'phone'
          | 'postalCode'
          | 'remarks'
          | 'sortCodeId'
          | 'sortCodeName'
          | 'website'
        >
        & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
      )>,
    }
  )> };

export type getBatch_queryQueryVariables = Exact<{
  input?: InputMaybe<getBatchInput>;
}>;


export type getBatch_queryQuery = { getBatch?: Maybe<(
    Pick<
      Batch,
      | 'amount'
      | 'creditAmount'
      | 'debitAmount'
      | 'details'
      | 'id'
      | 'initDate'
      | 'initTime'
      | 'issueDate'
      | 'status'
      | 'type'
    >
    & { transactions?: Maybe<Array<Maybe<(
      Pick<
        Transaction,
        | 'authorizedDealerNumber'
        | 'batchId'
        | 'branch'
        | 'branchName'
        | 'chequeId'
        | 'costingCode'
        | 'costingCodeName'
        | 'costingCodeFilter'
        | 'creditorId'
        | 'currencyCode'
        | 'date3'
        | 'debtorId'
        | 'description'
        | 'details1'
        | 'details2'
        | 'dueDate'
        | 'exchangeRateDifferences'
        | 'foreignCurrencySum'
        | 'id'
        | 'inventoryId'
        | 'linkedFile'
        | 'quantity'
        | 'reference1'
        | 'reference2'
        | 'reference3'
        | 'registerNumber'
        | 'shekelSum'
        | 'stornoCancelledTransactionId'
        | 'type'
        | 'userName'
        | 'valueDate'
      >
      & {
        records?: Maybe<Array<Maybe<(
          Pick<
            RecordType,
            | 'accountId'
            | 'batchId'
            | 'counterAccountId'
            | 'counterAccountName'
            | 'cumulativeBalance'
            | 'cumulativeBalanceByFilter'
            | 'cumulativeBalanceBySortKey'
            | 'cumulativeBalanceOfOpenSumInRecord'
            | 'cumulativeBalanceWithoutOpeningBalance'
            | 'debitOrCredit'
            | 'debitOrCreditNumber'
            | 'estimatedSum'
            | 'foreignCurrencyCredit'
            | 'foreignCurrencyCumulativeBalance'
            | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
            | 'foreignCurrencyDebit'
            | 'foreignCurrencySum'
            | 'foreignCurrencySumClosedInRecord'
            | 'foreignCurrencySumOpenInRecord'
            | 'id'
            | 'matchNumberCardAnalysis'
            | 'shekelCredit'
            | 'shekelDebit'
            | 'shekelSum'
            | 'shekelSumClosedInRecord'
            | 'shekelSumOpenInRecord'
            | 'transactionId'
          >
          & {
            account?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
            counterAccount?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
          }
        )>>>,
        creditor?: Maybe<(
          Pick<
            Account,
            | 'accountingCode'
            | 'address'
            | 'balanceCode'
            | 'cellphone'
            | 'city'
            | 'costingCode'
            | 'country'
            | 'email'
            | 'fax'
            | 'filter'
            | 'id'
            | 'idOrCompanyNum'
            | 'initDate'
            | 'mainAccount'
            | 'mainAccountCode'
            | 'name'
            | 'phone'
            | 'postalCode'
            | 'remarks'
            | 'sortCodeId'
            | 'sortCodeName'
            | 'website'
          >
          & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
        )>,
        debtor?: Maybe<(
          Pick<
            Account,
            | 'accountingCode'
            | 'address'
            | 'balanceCode'
            | 'cellphone'
            | 'city'
            | 'costingCode'
            | 'country'
            | 'email'
            | 'fax'
            | 'filter'
            | 'id'
            | 'idOrCompanyNum'
            | 'initDate'
            | 'mainAccount'
            | 'mainAccountCode'
            | 'name'
            | 'phone'
            | 'postalCode'
            | 'remarks'
            | 'sortCodeId'
            | 'sortCodeName'
            | 'website'
          >
          & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
        )>,
      }
    )>>> }
  )> };

export type getBankPageRecords_queryQueryVariables = Exact<{
  input?: InputMaybe<getBankPageRecordsInput>;
}>;


export type getBankPageRecords_queryQuery = { getBankPageRecords: Array<(
    Pick<
      BankPageRecord,
      | 'accountId'
      | 'accountName'
      | 'adjustedRecord'
      | 'bankPageId'
      | 'cumulativeBalance'
      | 'cumulativeBalanceCalculated'
      | 'date'
      | 'debitOrCredit'
      | 'details'
      | 'id'
      | 'matchNumber'
      | 'reference'
      | 'sum'
    >
    & { account?: Maybe<(
      Pick<
        Account,
        | 'accountingCode'
        | 'address'
        | 'balanceCode'
        | 'cellphone'
        | 'city'
        | 'costingCode'
        | 'country'
        | 'email'
        | 'fax'
        | 'filter'
        | 'id'
        | 'idOrCompanyNum'
        | 'initDate'
        | 'mainAccount'
        | 'mainAccountCode'
        | 'name'
        | 'phone'
        | 'postalCode'
        | 'remarks'
        | 'sortCodeId'
        | 'sortCodeName'
        | 'website'
      >
      & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
    )> }
  )> };

export type importTransactionsToBatch_mutationMutationVariables = Exact<{
  input?: InputMaybe<mutationInput_importTransactionsToBatch_input_Input>;
}>;


export type importTransactionsToBatch_mutationMutation = { importTransactionsToBatch?: Maybe<(
    Pick<
      importTransactionsToBatchResponse,
      | 'status'
      | 'batch_issue'
      | 'newbatch'
      | 'batchno'
    >
    & {
      batch_check?: Maybe<Array<Maybe<
        | Pick<String_container, 'String'>
        | Pick<
            query_checkBatch_batch_check_oneOf_1_items,
            | 'headerID'
            | 'err'
            | 'recId'
            | 'field'
            | 'TxtMsg'
          >
      >>>,
      errors?: Maybe<Array<Maybe<
        | Pick<
            mutation_importTransactionsToBatch_errors_oneOf_0_items,
            | 'headerID'
            | 'err'
            | 'recId'
            | 'field'
            | 'TxtMsg'
          >
        | Pick<String_container, 'String'>
      >>>,
      batch?: Maybe<(
        Pick<
          Batch,
          | 'amount'
          | 'creditAmount'
          | 'debitAmount'
          | 'details'
          | 'id'
          | 'initDate'
          | 'initTime'
          | 'issueDate'
          | 'status'
          | 'type'
        >
        & { transactions?: Maybe<Array<Maybe<(
          Pick<
            Transaction,
            | 'authorizedDealerNumber'
            | 'batchId'
            | 'branch'
            | 'branchName'
            | 'chequeId'
            | 'costingCode'
            | 'costingCodeName'
            | 'costingCodeFilter'
            | 'creditorId'
            | 'currencyCode'
            | 'date3'
            | 'debtorId'
            | 'description'
            | 'details1'
            | 'details2'
            | 'dueDate'
            | 'exchangeRateDifferences'
            | 'foreignCurrencySum'
            | 'id'
            | 'inventoryId'
            | 'linkedFile'
            | 'quantity'
            | 'reference1'
            | 'reference2'
            | 'reference3'
            | 'registerNumber'
            | 'shekelSum'
            | 'stornoCancelledTransactionId'
            | 'type'
            | 'userName'
            | 'valueDate'
          >
          & {
            records?: Maybe<Array<Maybe<(
              Pick<
                RecordType,
                | 'accountId'
                | 'batchId'
                | 'counterAccountId'
                | 'counterAccountName'
                | 'cumulativeBalance'
                | 'cumulativeBalanceByFilter'
                | 'cumulativeBalanceBySortKey'
                | 'cumulativeBalanceOfOpenSumInRecord'
                | 'cumulativeBalanceWithoutOpeningBalance'
                | 'debitOrCredit'
                | 'debitOrCreditNumber'
                | 'estimatedSum'
                | 'foreignCurrencyCredit'
                | 'foreignCurrencyCumulativeBalance'
                | 'foreignCurrencyCumulativeBalanceWithoutOpeningBalance'
                | 'foreignCurrencyDebit'
                | 'foreignCurrencySum'
                | 'foreignCurrencySumClosedInRecord'
                | 'foreignCurrencySumOpenInRecord'
                | 'id'
                | 'matchNumberCardAnalysis'
                | 'shekelCredit'
                | 'shekelDebit'
                | 'shekelSum'
                | 'shekelSumClosedInRecord'
                | 'shekelSumOpenInRecord'
                | 'transactionId'
              >
              & {
                account?: Maybe<Pick<
                    Account,
                    | 'accountingCode'
                    | 'address'
                    | 'balanceCode'
                    | 'cellphone'
                    | 'city'
                    | 'costingCode'
                    | 'country'
                    | 'email'
                    | 'fax'
                    | 'filter'
                    | 'id'
                    | 'idOrCompanyNum'
                    | 'initDate'
                    | 'mainAccount'
                    | 'mainAccountCode'
                    | 'name'
                    | 'phone'
                    | 'postalCode'
                    | 'remarks'
                    | 'sortCodeId'
                    | 'sortCodeName'
                    | 'website'
                  >>,
                counterAccount?: Maybe<Pick<
                    Account,
                    | 'accountingCode'
                    | 'address'
                    | 'balanceCode'
                    | 'cellphone'
                    | 'city'
                    | 'costingCode'
                    | 'country'
                    | 'email'
                    | 'fax'
                    | 'filter'
                    | 'id'
                    | 'idOrCompanyNum'
                    | 'initDate'
                    | 'mainAccount'
                    | 'mainAccountCode'
                    | 'name'
                    | 'phone'
                    | 'postalCode'
                    | 'remarks'
                    | 'sortCodeId'
                    | 'sortCodeName'
                    | 'website'
                  >>,
              }
            )>>>,
            creditor?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
            debtor?: Maybe<(
              Pick<
                Account,
                | 'accountingCode'
                | 'address'
                | 'balanceCode'
                | 'cellphone'
                | 'city'
                | 'costingCode'
                | 'country'
                | 'email'
                | 'fax'
                | 'filter'
                | 'id'
                | 'idOrCompanyNum'
                | 'initDate'
                | 'mainAccount'
                | 'mainAccountCode'
                | 'name'
                | 'phone'
                | 'postalCode'
                | 'remarks'
                | 'sortCodeId'
                | 'sortCodeName'
                | 'website'
              >
              & { sortCode?: Maybe<Pick<SortCode, 'code' | 'name'>> }
            )>,
          }
        )>>> }
      )>,
    }
  )> };

export type createBatch_mutationMutationVariables = Exact<{ [key: string]: never; }>;


export type createBatch_mutationMutation = { createBatch?: Maybe<Pick<createBatch, 'newbatch'>> };

export type issueBatch_mutationMutationVariables = Exact<{
  input?: InputMaybe<mutationInput_issueBatch_input_Input>;
}>;


export type issueBatch_mutationMutation = { issueBatch?: Maybe<(
    Pick<issueBatchResponse, 'batch_issue'>
    & { batch_check?: Maybe<Array<Maybe<
      | Pick<String_container, 'String'>
      | Pick<
          query_checkBatch_batch_check_oneOf_1_items,
          | 'headerID'
          | 'err'
          | 'recId'
          | 'field'
          | 'TxtMsg'
        >
    >>> }
  )> };

export type importAccountsRaw_mutationMutationVariables = Exact<{
  input?: InputMaybe<importAccountsRawRequest_Input>;
}>;


export type importAccountsRaw_mutationMutation = { importAccountsRaw?: Maybe<(
    Pick<importAccountsResponse, 'status'>
    & { errors: Array<Maybe<Pick<mutation_importAccountsRaw_errors_items, 'index' | 'field' | 'err'>>> }
  )> };

export type importBankPage_mutationMutationVariables = Exact<{
  input?: InputMaybe<mutationInput_importBankPage_input_Input>;
}>;


export type importBankPage_mutationMutation = { importBankPage?: Maybe<(
    Pick<importBankPageResponse, 'status'>
    & { errors: Array<Maybe<Pick<mutation_importBankPage_errors_items, 'index' | 'field' | 'err'>>> }
  )> };

export type importAccounts_mutationMutationVariables = Exact<{
  input?: InputMaybe<importAccountsInput>;
}>;


export type importAccounts_mutationMutation = { importAccounts?: Maybe<(
    Pick<importAccountsResponse, 'status'>
    & { errors: Array<Maybe<Pick<mutation_importAccountsRaw_errors_items, 'index' | 'field' | 'err'>>> }
  )> };


export const getSession_queryDocument = gql`
    query getSession_query {
  getSession {
    data
    session {
      branch
      cid
      company_id
      company_name
      use_name
      user
      user_id
      wizcomp_no
    }
  }
}
    ` as unknown as DocumentNode<getSession_queryQuery, getSession_queryQueryVariables>;
export const getCompanies_queryDocument = gql`
    query getCompanies_query {
  getCompanies {
    status {
      repdata {
        Comp_Vatnum
        Company_File_Name
        Company_Name
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getCompanies_queryQuery, getCompanies_queryQueryVariables>;
export const getRecordsRaw_queryDocument = gql`
    query getRecordsRaw_query($input: queryInput_getRecordsRaw_input_Input) {
  getRecordsRaw(input: $input) {
    status {
      repdata {
        accountId
        batchId
        counterAccountId
        counterAccountName
        cumulativeBalance
        cumulativeBalanceByFilter
        cumulativeBalanceBySortKey
        cumulativeBalanceOfOpenSumInRecord
        cumulativeBalanceWithoutOpeningBalance
        debitOrCredit
        debitOrCreditNumber
        estimatedSum
        foreignCurrencyCredit
        foreignCurrencyCumulativeBalance
        foreignCurrencyCumulativeBalanceWithoutOpeningBalance
        foreignCurrencyDebit
        foreignCurrencySum
        foreignCurrencySumClosedInRecord
        foreignCurrencySumOpenInRecord
        id
        matchNumberCardAnalysis
        shekelCredit
        shekelDebit
        shekelSum
        shekelSumClosedInRecord
        shekelSumOpenInRecord
        transactionId
        transaction {
          authorizedDealerNumber
          batchId
          branch
          branchName
          chequeId
          costingCode
          costingCodeName
          costingCodeFilter
          creditorId
          currencyCode
          date3
          debtorId
          description
          details1
          details2
          dueDate
          exchangeRateDifferences
          foreignCurrencySum
          id
          inventoryId
          linkedFile
          quantity
          reference1
          reference2
          reference3
          registerNumber
          shekelSum
          stornoCancelledTransactionId
          type
          userName
          valueDate
          batch {
            amount
            creditAmount
            debitAmount
            details
            id
            initDate
            initTime
            issueDate
            status
            type
          }
          creditor {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
          debtor {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
        }
        batch {
          amount
          creditAmount
          debitAmount
          details
          id
          initDate
          initTime
          issueDate
          status
          type
          transactions {
            authorizedDealerNumber
            batchId
            branch
            branchName
            chequeId
            costingCode
            costingCodeName
            costingCodeFilter
            creditorId
            currencyCode
            date3
            debtorId
            description
            details1
            details2
            dueDate
            exchangeRateDifferences
            foreignCurrencySum
            id
            inventoryId
            linkedFile
            quantity
            reference1
            reference2
            reference3
            registerNumber
            shekelSum
            stornoCancelledTransactionId
            type
            userName
            valueDate
          }
        }
        account {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
        counterAccount {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getRecordsRaw_queryQuery, getRecordsRaw_queryQueryVariables>;
export const getTransactionsRaw_queryDocument = gql`
    query getTransactionsRaw_query($input: queryInput_getTransactionsRaw_input_Input) {
  getTransactionsRaw(input: $input) {
    status {
      repdata {
        authorizedDealerNumber
        batchId
        branch
        branchName
        chequeId
        costingCode
        costingCodeName
        costingCodeFilter
        creditorId
        currencyCode
        date3
        debtorId
        description
        details1
        details2
        dueDate
        exchangeRateDifferences
        foreignCurrencySum
        id
        inventoryId
        linkedFile
        quantity
        reference1
        reference2
        reference3
        registerNumber
        shekelSum
        stornoCancelledTransactionId
        type
        userName
        valueDate
        batch {
          amount
          creditAmount
          debitAmount
          details
          id
          initDate
          initTime
          issueDate
          status
          type
        }
        records {
          accountId
          batchId
          counterAccountId
          counterAccountName
          cumulativeBalance
          cumulativeBalanceByFilter
          cumulativeBalanceBySortKey
          cumulativeBalanceOfOpenSumInRecord
          cumulativeBalanceWithoutOpeningBalance
          debitOrCredit
          debitOrCreditNumber
          estimatedSum
          foreignCurrencyCredit
          foreignCurrencyCumulativeBalance
          foreignCurrencyCumulativeBalanceWithoutOpeningBalance
          foreignCurrencyDebit
          foreignCurrencySum
          foreignCurrencySumClosedInRecord
          foreignCurrencySumOpenInRecord
          id
          matchNumberCardAnalysis
          shekelCredit
          shekelDebit
          shekelSum
          shekelSumClosedInRecord
          shekelSumOpenInRecord
          transactionId
          batch {
            amount
            creditAmount
            debitAmount
            details
            id
            initDate
            initTime
            issueDate
            status
            type
          }
          account {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
          counterAccount {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
        }
        creditor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
        debtor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getTransactionsRaw_queryQuery, getTransactionsRaw_queryQueryVariables>;
export const getBatchRaw_queryDocument = gql`
    query getBatchRaw_query($input: queryInput_getBatchRaw_input_Input) {
  getBatchRaw(input: $input) {
    status {
      repdata {
        amount
        creditAmount
        debitAmount
        details
        id
        initDate
        initTime
        issueDate
        status
        type
        transactions {
          authorizedDealerNumber
          batchId
          branch
          branchName
          chequeId
          costingCode
          costingCodeName
          costingCodeFilter
          creditorId
          currencyCode
          date3
          debtorId
          description
          details1
          details2
          dueDate
          exchangeRateDifferences
          foreignCurrencySum
          id
          inventoryId
          linkedFile
          quantity
          reference1
          reference2
          reference3
          registerNumber
          shekelSum
          stornoCancelledTransactionId
          type
          userName
          valueDate
          records {
            accountId
            batchId
            counterAccountId
            counterAccountName
            cumulativeBalance
            cumulativeBalanceByFilter
            cumulativeBalanceBySortKey
            cumulativeBalanceOfOpenSumInRecord
            cumulativeBalanceWithoutOpeningBalance
            debitOrCredit
            debitOrCreditNumber
            estimatedSum
            foreignCurrencyCredit
            foreignCurrencyCumulativeBalance
            foreignCurrencyCumulativeBalanceWithoutOpeningBalance
            foreignCurrencyDebit
            foreignCurrencySum
            foreignCurrencySumClosedInRecord
            foreignCurrencySumOpenInRecord
            id
            matchNumberCardAnalysis
            shekelCredit
            shekelDebit
            shekelSum
            shekelSumClosedInRecord
            shekelSumOpenInRecord
            transactionId
          }
          creditor {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
          debtor {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getBatchRaw_queryQuery, getBatchRaw_queryQueryVariables>;
export const checkBatch_queryDocument = gql`
    query checkBatch_query($input: queryInput_checkBatch_input_Input) {
  checkBatch(input: $input) {
    batch_check {
      ... on String_container {
        String
      }
      ... on query_checkBatch_batch_check_oneOf_1_items {
        headerID
        err
        recId
        field
        TxtMsg
      }
    }
  }
}
    ` as unknown as DocumentNode<checkBatch_queryQuery, checkBatch_queryQueryVariables>;
export const getAccountsRaw_queryDocument = gql`
    query getAccountsRaw_query($input: queryInput_getAccountsRaw_input_Input) {
  getAccountsRaw(input: $input) {
    status {
      repdata {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getAccountsRaw_queryQuery, getAccountsRaw_queryQueryVariables>;
export const getBankPageRecordsRaw_queryDocument = gql`
    query getBankPageRecordsRaw_query($input: queryInput_getBankPageRecordsRaw_input_Input) {
  getBankPageRecordsRaw(input: $input) {
    status {
      repdata {
        accountId
        accountName
        adjustedRecord
        bankPageId
        cumulativeBalance
        cumulativeBalanceCalculated
        date
        debitOrCredit
        details
        id
        matchNumber
        reference
        sum
        account {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getBankPageRecordsRaw_queryQuery, getBankPageRecordsRaw_queryQueryVariables>;
export const getSortCodesRaw_queryDocument = gql`
    query getSortCodesRaw_query($input: queryInput_getSortCodesRaw_input_Input) {
  getSortCodesRaw(input: $input) {
    status {
      repdata {
        code
        name
        accounts {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
        }
      }
      errors
    }
    statusCode
  }
}
    ` as unknown as DocumentNode<getSortCodesRaw_queryQuery, getSortCodesRaw_queryQueryVariables>;
export const getSortCodes_queryDocument = gql`
    query getSortCodes_query {
  getSortCodes {
    code
    name
    accounts {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
    }
  }
}
    ` as unknown as DocumentNode<getSortCodes_queryQuery, getSortCodes_queryQueryVariables>;
export const getAccounts_queryDocument = gql`
    query getAccounts_query($input: getAccountsInput) {
  getAccounts(input: $input) {
    accountingCode
    address
    balanceCode
    cellphone
    city
    costingCode
    country
    email
    fax
    filter
    id
    idOrCompanyNum
    initDate
    mainAccount
    mainAccountCode
    name
    phone
    postalCode
    remarks
    sortCodeId
    sortCodeName
    website
    sortCode {
      code
      name
    }
  }
}
    ` as unknown as DocumentNode<getAccounts_queryQuery, getAccounts_queryQueryVariables>;
export const getRecords_queryDocument = gql`
    query getRecords_query($input: getRecordsInput) {
  getRecords(input: $input) {
    accountId
    batchId
    counterAccountId
    counterAccountName
    cumulativeBalance
    cumulativeBalanceByFilter
    cumulativeBalanceBySortKey
    cumulativeBalanceOfOpenSumInRecord
    cumulativeBalanceWithoutOpeningBalance
    debitOrCredit
    debitOrCreditNumber
    estimatedSum
    foreignCurrencyCredit
    foreignCurrencyCumulativeBalance
    foreignCurrencyCumulativeBalanceWithoutOpeningBalance
    foreignCurrencyDebit
    foreignCurrencySum
    foreignCurrencySumClosedInRecord
    foreignCurrencySumOpenInRecord
    id
    matchNumberCardAnalysis
    shekelCredit
    shekelDebit
    shekelSum
    shekelSumClosedInRecord
    shekelSumOpenInRecord
    transactionId
    transaction {
      authorizedDealerNumber
      batchId
      branch
      branchName
      chequeId
      costingCode
      costingCodeName
      costingCodeFilter
      creditorId
      currencyCode
      date3
      debtorId
      description
      details1
      details2
      dueDate
      exchangeRateDifferences
      foreignCurrencySum
      id
      inventoryId
      linkedFile
      quantity
      reference1
      reference2
      reference3
      registerNumber
      shekelSum
      stornoCancelledTransactionId
      type
      userName
      valueDate
      batch {
        amount
        creditAmount
        debitAmount
        details
        id
        initDate
        initTime
        issueDate
        status
        type
      }
      creditor {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
      debtor {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
    }
    batch {
      amount
      creditAmount
      debitAmount
      details
      id
      initDate
      initTime
      issueDate
      status
      type
      transactions {
        authorizedDealerNumber
        batchId
        branch
        branchName
        chequeId
        costingCode
        costingCodeName
        costingCodeFilter
        creditorId
        currencyCode
        date3
        debtorId
        description
        details1
        details2
        dueDate
        exchangeRateDifferences
        foreignCurrencySum
        id
        inventoryId
        linkedFile
        quantity
        reference1
        reference2
        reference3
        registerNumber
        shekelSum
        stornoCancelledTransactionId
        type
        userName
        valueDate
        creditor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
        debtor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
    }
    account {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
      sortCode {
        code
        name
      }
    }
    counterAccount {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
      sortCode {
        code
        name
      }
    }
  }
}
    ` as unknown as DocumentNode<getRecords_queryQuery, getRecords_queryQueryVariables>;
export const getTransactions_queryDocument = gql`
    query getTransactions_query($input: getTransactionsInput) {
  getTransactions(input: $input) {
    authorizedDealerNumber
    batchId
    branch
    branchName
    chequeId
    costingCode
    costingCodeName
    costingCodeFilter
    creditorId
    currencyCode
    date3
    debtorId
    description
    details1
    details2
    dueDate
    exchangeRateDifferences
    foreignCurrencySum
    id
    inventoryId
    linkedFile
    quantity
    reference1
    reference2
    reference3
    registerNumber
    shekelSum
    stornoCancelledTransactionId
    type
    userName
    valueDate
    batch {
      amount
      creditAmount
      debitAmount
      details
      id
      initDate
      initTime
      issueDate
      status
      type
    }
    records {
      accountId
      batchId
      counterAccountId
      counterAccountName
      cumulativeBalance
      cumulativeBalanceByFilter
      cumulativeBalanceBySortKey
      cumulativeBalanceOfOpenSumInRecord
      cumulativeBalanceWithoutOpeningBalance
      debitOrCredit
      debitOrCreditNumber
      estimatedSum
      foreignCurrencyCredit
      foreignCurrencyCumulativeBalance
      foreignCurrencyCumulativeBalanceWithoutOpeningBalance
      foreignCurrencyDebit
      foreignCurrencySum
      foreignCurrencySumClosedInRecord
      foreignCurrencySumOpenInRecord
      id
      matchNumberCardAnalysis
      shekelCredit
      shekelDebit
      shekelSum
      shekelSumClosedInRecord
      shekelSumOpenInRecord
      transactionId
      batch {
        amount
        creditAmount
        debitAmount
        details
        id
        initDate
        initTime
        issueDate
        status
        type
      }
      account {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
      counterAccount {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
    }
    creditor {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
      sortCode {
        code
        name
      }
    }
    debtor {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
      sortCode {
        code
        name
      }
    }
  }
}
    ` as unknown as DocumentNode<getTransactions_queryQuery, getTransactions_queryQueryVariables>;
export const getBatch_queryDocument = gql`
    query getBatch_query($input: getBatchInput) {
  getBatch(input: $input) {
    amount
    creditAmount
    debitAmount
    details
    id
    initDate
    initTime
    issueDate
    status
    type
    transactions {
      authorizedDealerNumber
      batchId
      branch
      branchName
      chequeId
      costingCode
      costingCodeName
      costingCodeFilter
      creditorId
      currencyCode
      date3
      debtorId
      description
      details1
      details2
      dueDate
      exchangeRateDifferences
      foreignCurrencySum
      id
      inventoryId
      linkedFile
      quantity
      reference1
      reference2
      reference3
      registerNumber
      shekelSum
      stornoCancelledTransactionId
      type
      userName
      valueDate
      records {
        accountId
        batchId
        counterAccountId
        counterAccountName
        cumulativeBalance
        cumulativeBalanceByFilter
        cumulativeBalanceBySortKey
        cumulativeBalanceOfOpenSumInRecord
        cumulativeBalanceWithoutOpeningBalance
        debitOrCredit
        debitOrCreditNumber
        estimatedSum
        foreignCurrencyCredit
        foreignCurrencyCumulativeBalance
        foreignCurrencyCumulativeBalanceWithoutOpeningBalance
        foreignCurrencyDebit
        foreignCurrencySum
        foreignCurrencySumClosedInRecord
        foreignCurrencySumOpenInRecord
        id
        matchNumberCardAnalysis
        shekelCredit
        shekelDebit
        shekelSum
        shekelSumClosedInRecord
        shekelSumOpenInRecord
        transactionId
        account {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
        counterAccount {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
      creditor {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
      debtor {
        accountingCode
        address
        balanceCode
        cellphone
        city
        costingCode
        country
        email
        fax
        filter
        id
        idOrCompanyNum
        initDate
        mainAccount
        mainAccountCode
        name
        phone
        postalCode
        remarks
        sortCodeId
        sortCodeName
        website
        sortCode {
          code
          name
        }
      }
    }
  }
}
    ` as unknown as DocumentNode<getBatch_queryQuery, getBatch_queryQueryVariables>;
export const getBankPageRecords_queryDocument = gql`
    query getBankPageRecords_query($input: getBankPageRecordsInput) {
  getBankPageRecords(input: $input) {
    accountId
    accountName
    adjustedRecord
    bankPageId
    cumulativeBalance
    cumulativeBalanceCalculated
    date
    debitOrCredit
    details
    id
    matchNumber
    reference
    sum
    account {
      accountingCode
      address
      balanceCode
      cellphone
      city
      costingCode
      country
      email
      fax
      filter
      id
      idOrCompanyNum
      initDate
      mainAccount
      mainAccountCode
      name
      phone
      postalCode
      remarks
      sortCodeId
      sortCodeName
      website
      sortCode {
        code
        name
      }
    }
  }
}
    ` as unknown as DocumentNode<getBankPageRecords_queryQuery, getBankPageRecords_queryQueryVariables>;
export const importTransactionsToBatch_mutationDocument = gql`
    mutation importTransactionsToBatch_mutation($input: mutationInput_importTransactionsToBatch_input_Input) {
  importTransactionsToBatch(input: $input) {
    status
    batch_issue
    batch_check {
      ... on String_container {
        String
      }
      ... on query_checkBatch_batch_check_oneOf_1_items {
        headerID
        err
        recId
        field
        TxtMsg
      }
    }
    newbatch
    batchno
    errors {
      ... on mutation_importTransactionsToBatch_errors_oneOf_0_items {
        headerID
        err
        recId
        field
        TxtMsg
      }
      ... on String_container {
        String
      }
    }
    batch {
      amount
      creditAmount
      debitAmount
      details
      id
      initDate
      initTime
      issueDate
      status
      type
      transactions {
        authorizedDealerNumber
        batchId
        branch
        branchName
        chequeId
        costingCode
        costingCodeName
        costingCodeFilter
        creditorId
        currencyCode
        date3
        debtorId
        description
        details1
        details2
        dueDate
        exchangeRateDifferences
        foreignCurrencySum
        id
        inventoryId
        linkedFile
        quantity
        reference1
        reference2
        reference3
        registerNumber
        shekelSum
        stornoCancelledTransactionId
        type
        userName
        valueDate
        records {
          accountId
          batchId
          counterAccountId
          counterAccountName
          cumulativeBalance
          cumulativeBalanceByFilter
          cumulativeBalanceBySortKey
          cumulativeBalanceOfOpenSumInRecord
          cumulativeBalanceWithoutOpeningBalance
          debitOrCredit
          debitOrCreditNumber
          estimatedSum
          foreignCurrencyCredit
          foreignCurrencyCumulativeBalance
          foreignCurrencyCumulativeBalanceWithoutOpeningBalance
          foreignCurrencyDebit
          foreignCurrencySum
          foreignCurrencySumClosedInRecord
          foreignCurrencySumOpenInRecord
          id
          matchNumberCardAnalysis
          shekelCredit
          shekelDebit
          shekelSum
          shekelSumClosedInRecord
          shekelSumOpenInRecord
          transactionId
          account {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
          counterAccount {
            accountingCode
            address
            balanceCode
            cellphone
            city
            costingCode
            country
            email
            fax
            filter
            id
            idOrCompanyNum
            initDate
            mainAccount
            mainAccountCode
            name
            phone
            postalCode
            remarks
            sortCodeId
            sortCodeName
            website
          }
        }
        creditor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
        debtor {
          accountingCode
          address
          balanceCode
          cellphone
          city
          costingCode
          country
          email
          fax
          filter
          id
          idOrCompanyNum
          initDate
          mainAccount
          mainAccountCode
          name
          phone
          postalCode
          remarks
          sortCodeId
          sortCodeName
          website
          sortCode {
            code
            name
          }
        }
      }
    }
  }
}
    ` as unknown as DocumentNode<importTransactionsToBatch_mutationMutation, importTransactionsToBatch_mutationMutationVariables>;
export const createBatch_mutationDocument = gql`
    mutation createBatch_mutation {
  createBatch {
    newbatch
  }
}
    ` as unknown as DocumentNode<createBatch_mutationMutation, createBatch_mutationMutationVariables>;
export const issueBatch_mutationDocument = gql`
    mutation issueBatch_mutation($input: mutationInput_issueBatch_input_Input) {
  issueBatch(input: $input) {
    batch_check {
      ... on String_container {
        String
      }
      ... on query_checkBatch_batch_check_oneOf_1_items {
        headerID
        err
        recId
        field
        TxtMsg
      }
    }
    batch_issue
  }
}
    ` as unknown as DocumentNode<issueBatch_mutationMutation, issueBatch_mutationMutationVariables>;
export const importAccountsRaw_mutationDocument = gql`
    mutation importAccountsRaw_mutation($input: importAccountsRawRequest_Input) {
  importAccountsRaw(input: $input) {
    status
    errors {
      index
      field
      err
    }
  }
}
    ` as unknown as DocumentNode<importAccountsRaw_mutationMutation, importAccountsRaw_mutationMutationVariables>;
export const importBankPage_mutationDocument = gql`
    mutation importBankPage_mutation($input: mutationInput_importBankPage_input_Input) {
  importBankPage(input: $input) {
    status
    errors {
      index
      field
      err
    }
  }
}
    ` as unknown as DocumentNode<importBankPage_mutationMutation, importBankPage_mutationMutationVariables>;
export const importAccounts_mutationDocument = gql`
    mutation importAccounts_mutation($input: importAccountsInput) {
  importAccounts(input: $input) {
    status
    errors {
      index
      field
      err
    }
  }
}
    ` as unknown as DocumentNode<importAccounts_mutationMutation, importAccounts_mutationMutationVariables>;






















export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>
export function getSdk<C>(requester: Requester<C>) {
  return {
    getSession_query(variables?: getSession_queryQueryVariables, options?: C): Promise<getSession_queryQuery> {
      return requester<getSession_queryQuery, getSession_queryQueryVariables>(getSession_queryDocument, variables, options) as Promise<getSession_queryQuery>;
    },
    getCompanies_query(variables?: getCompanies_queryQueryVariables, options?: C): Promise<getCompanies_queryQuery> {
      return requester<getCompanies_queryQuery, getCompanies_queryQueryVariables>(getCompanies_queryDocument, variables, options) as Promise<getCompanies_queryQuery>;
    },
    getRecordsRaw_query(variables?: getRecordsRaw_queryQueryVariables, options?: C): Promise<getRecordsRaw_queryQuery> {
      return requester<getRecordsRaw_queryQuery, getRecordsRaw_queryQueryVariables>(getRecordsRaw_queryDocument, variables, options) as Promise<getRecordsRaw_queryQuery>;
    },
    getTransactionsRaw_query(variables?: getTransactionsRaw_queryQueryVariables, options?: C): Promise<getTransactionsRaw_queryQuery> {
      return requester<getTransactionsRaw_queryQuery, getTransactionsRaw_queryQueryVariables>(getTransactionsRaw_queryDocument, variables, options) as Promise<getTransactionsRaw_queryQuery>;
    },
    getBatchRaw_query(variables?: getBatchRaw_queryQueryVariables, options?: C): Promise<getBatchRaw_queryQuery> {
      return requester<getBatchRaw_queryQuery, getBatchRaw_queryQueryVariables>(getBatchRaw_queryDocument, variables, options) as Promise<getBatchRaw_queryQuery>;
    },
    checkBatch_query(variables?: checkBatch_queryQueryVariables, options?: C): Promise<checkBatch_queryQuery> {
      return requester<checkBatch_queryQuery, checkBatch_queryQueryVariables>(checkBatch_queryDocument, variables, options) as Promise<checkBatch_queryQuery>;
    },
    getAccountsRaw_query(variables?: getAccountsRaw_queryQueryVariables, options?: C): Promise<getAccountsRaw_queryQuery> {
      return requester<getAccountsRaw_queryQuery, getAccountsRaw_queryQueryVariables>(getAccountsRaw_queryDocument, variables, options) as Promise<getAccountsRaw_queryQuery>;
    },
    getBankPageRecordsRaw_query(variables?: getBankPageRecordsRaw_queryQueryVariables, options?: C): Promise<getBankPageRecordsRaw_queryQuery> {
      return requester<getBankPageRecordsRaw_queryQuery, getBankPageRecordsRaw_queryQueryVariables>(getBankPageRecordsRaw_queryDocument, variables, options) as Promise<getBankPageRecordsRaw_queryQuery>;
    },
    getSortCodesRaw_query(variables?: getSortCodesRaw_queryQueryVariables, options?: C): Promise<getSortCodesRaw_queryQuery> {
      return requester<getSortCodesRaw_queryQuery, getSortCodesRaw_queryQueryVariables>(getSortCodesRaw_queryDocument, variables, options) as Promise<getSortCodesRaw_queryQuery>;
    },
    getSortCodes_query(variables?: getSortCodes_queryQueryVariables, options?: C): Promise<getSortCodes_queryQuery> {
      return requester<getSortCodes_queryQuery, getSortCodes_queryQueryVariables>(getSortCodes_queryDocument, variables, options) as Promise<getSortCodes_queryQuery>;
    },
    getAccounts_query(variables?: getAccounts_queryQueryVariables, options?: C): Promise<getAccounts_queryQuery> {
      return requester<getAccounts_queryQuery, getAccounts_queryQueryVariables>(getAccounts_queryDocument, variables, options) as Promise<getAccounts_queryQuery>;
    },
    getRecords_query(variables?: getRecords_queryQueryVariables, options?: C): Promise<getRecords_queryQuery> {
      return requester<getRecords_queryQuery, getRecords_queryQueryVariables>(getRecords_queryDocument, variables, options) as Promise<getRecords_queryQuery>;
    },
    getTransactions_query(variables?: getTransactions_queryQueryVariables, options?: C): Promise<getTransactions_queryQuery> {
      return requester<getTransactions_queryQuery, getTransactions_queryQueryVariables>(getTransactions_queryDocument, variables, options) as Promise<getTransactions_queryQuery>;
    },
    getBatch_query(variables?: getBatch_queryQueryVariables, options?: C): Promise<getBatch_queryQuery> {
      return requester<getBatch_queryQuery, getBatch_queryQueryVariables>(getBatch_queryDocument, variables, options) as Promise<getBatch_queryQuery>;
    },
    getBankPageRecords_query(variables?: getBankPageRecords_queryQueryVariables, options?: C): Promise<getBankPageRecords_queryQuery> {
      return requester<getBankPageRecords_queryQuery, getBankPageRecords_queryQueryVariables>(getBankPageRecords_queryDocument, variables, options) as Promise<getBankPageRecords_queryQuery>;
    },
    importTransactionsToBatch_mutation(variables?: importTransactionsToBatch_mutationMutationVariables, options?: C): Promise<importTransactionsToBatch_mutationMutation> {
      return requester<importTransactionsToBatch_mutationMutation, importTransactionsToBatch_mutationMutationVariables>(importTransactionsToBatch_mutationDocument, variables, options) as Promise<importTransactionsToBatch_mutationMutation>;
    },
    createBatch_mutation(variables?: createBatch_mutationMutationVariables, options?: C): Promise<createBatch_mutationMutation> {
      return requester<createBatch_mutationMutation, createBatch_mutationMutationVariables>(createBatch_mutationDocument, variables, options) as Promise<createBatch_mutationMutation>;
    },
    issueBatch_mutation(variables?: issueBatch_mutationMutationVariables, options?: C): Promise<issueBatch_mutationMutation> {
      return requester<issueBatch_mutationMutation, issueBatch_mutationMutationVariables>(issueBatch_mutationDocument, variables, options) as Promise<issueBatch_mutationMutation>;
    },
    importAccountsRaw_mutation(variables?: importAccountsRaw_mutationMutationVariables, options?: C): Promise<importAccountsRaw_mutationMutation> {
      return requester<importAccountsRaw_mutationMutation, importAccountsRaw_mutationMutationVariables>(importAccountsRaw_mutationDocument, variables, options) as Promise<importAccountsRaw_mutationMutation>;
    },
    importBankPage_mutation(variables?: importBankPage_mutationMutationVariables, options?: C): Promise<importBankPage_mutationMutation> {
      return requester<importBankPage_mutationMutation, importBankPage_mutationMutationVariables>(importBankPage_mutationDocument, variables, options) as Promise<importBankPage_mutationMutation>;
    },
    importAccounts_mutation(variables?: importAccounts_mutationMutationVariables, options?: C): Promise<importAccounts_mutationMutation> {
      return requester<importAccounts_mutationMutation, importAccounts_mutationMutationVariables>(importAccounts_mutationDocument, variables, options) as Promise<importAccounts_mutationMutation>;
    }
  };
}
export type Sdk = ReturnType<typeof getSdk>;