@accounter/hashavshevet-mesh/src/mesh-artifacts/sources/Hashavshevet/types.ts

Graphql proxy for Hashavshevet API

// @ts-nocheck

import type { InContextSdkMethod } from '@graphql-mesh/types';

export namespace HashavshevetTypes {
  export type Maybe<T> = T | null;
export type InputMaybe<T> = Maybe<T>;
/** 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 QuerySdk = {
      
  getSession: InContextSdkMethod<Query['getSession'], {}, BaseMeshContext>,
  
  getCompanies: InContextSdkMethod<Query['getCompanies'], {}, BaseMeshContext>,
  
  getRecordsRaw: InContextSdkMethod<Query['getRecordsRaw'], QuerygetRecordsRawArgs, BaseMeshContext>,
  
  getTransactionsRaw: InContextSdkMethod<Query['getTransactionsRaw'], QuerygetTransactionsRawArgs, BaseMeshContext>,
  
  getBatchRaw: InContextSdkMethod<Query['getBatchRaw'], QuerygetBatchRawArgs, BaseMeshContext>,
  
  checkBatch: InContextSdkMethod<Query['checkBatch'], QuerycheckBatchArgs, BaseMeshContext>,
  
  getAccountsRaw: InContextSdkMethod<Query['getAccountsRaw'], QuerygetAccountsRawArgs, BaseMeshContext>,
  
  getBankPageRecordsRaw: InContextSdkMethod<Query['getBankPageRecordsRaw'], QuerygetBankPageRecordsRawArgs, BaseMeshContext>,
  
  getSortCodesRaw: InContextSdkMethod<Query['getSortCodesRaw'], QuerygetSortCodesRawArgs, BaseMeshContext>,
  
  getSortCodes: InContextSdkMethod<Query['getSortCodes'], {}, BaseMeshContext>,
  
  getAccounts: InContextSdkMethod<Query['getAccounts'], QuerygetAccountsArgs, BaseMeshContext>,
  
  getRecords: InContextSdkMethod<Query['getRecords'], QuerygetRecordsArgs, BaseMeshContext>,
  
  getTransactions: InContextSdkMethod<Query['getTransactions'], QuerygetTransactionsArgs, BaseMeshContext>,
  
  getBatch: InContextSdkMethod<Query['getBatch'], QuerygetBatchArgs, BaseMeshContext>,
  
  getBankPageRecords: InContextSdkMethod<Query['getBankPageRecords'], QuerygetBankPageRecordsArgs, BaseMeshContext>
  };

  export type MutationSdk = {
      
  importTransactionsToBatch: InContextSdkMethod<Mutation['importTransactionsToBatch'], MutationimportTransactionsToBatchArgs, BaseMeshContext>,
  
  createBatch: InContextSdkMethod<Mutation['createBatch'], {}, BaseMeshContext>,
  
  issueBatch: InContextSdkMethod<Mutation['issueBatch'], MutationissueBatchArgs, BaseMeshContext>,
  
  importAccountsRaw: InContextSdkMethod<Mutation['importAccountsRaw'], MutationimportAccountsRawArgs, BaseMeshContext>,
  
  importBankPage: InContextSdkMethod<Mutation['importBankPage'], MutationimportBankPageArgs, BaseMeshContext>,
  
  importAccounts: InContextSdkMethod<Mutation['importAccounts'], MutationimportAccountsArgs, BaseMeshContext>
  };

  export type SubscriptionSdk = {
    
  };

  export type Context = {
      ["Hashavshevet"]: { Query: QuerySdk, Mutation: MutationSdk, Subscription: SubscriptionSdk },
      
    };
}