@accounter/client/src/gql/graphql.ts

Accounter client application

/* eslint-disable */
import type { TimelessDateString } from '../helpers/index.js';
import type { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
export type Maybe<T> = T | null;
export type InputMaybe<T> = T | null | undefined;
export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
export type MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  /**  BigInt  */
  BigInt: { input: bigint; output: bigint; }
  /**  Country Code  */
  CountryCode: { input: any; output: any; }
  /**  Date  */
  DateTime: { input: Date; output: Date; }
  /**  mock  */
  DividendMock: { input: any; output: any; }
  /**  File  */
  FileScalar: { input: File | Blob; output: string; }
  /**  Rate  */
  Rate: { input: any; output: any; }
  /**  Date with no time of day  */
  TimelessDate: { input: TimelessDateString; output: TimelessDateString; }
  /**  URL  */
  URL: { input: URL | string; output: URL | string; }
  /**  UUID  */
  UUID: { input: string; output: string; }
  /**  mock  */
  VatMock: { input: any; output: any; }
};

/**  Result payload returned after accepting an invitation  */
export type AcceptInvitationPayload = {
  __typename?: 'AcceptInvitationPayload';
  businessId: Scalars['ID']['output'];
  roleId: Scalars['String']['output'];
  success: Scalars['Boolean']['output'];
};

/**  represents accountant approval status for a charge  */
export type AccountantApprovalStatus = {
  __typename?: 'AccountantApprovalStatus';
  approvedCount: Scalars['Int']['output'];
  pendingCount: Scalars['Int']['output'];
  totalCharges: Scalars['Int']['output'];
  unapprovedCount: Scalars['Int']['output'];
};

/**  represents accountant approval status  */
export const AccountantStatus = {
  Approved: 'APPROVED',
  Pending: 'PENDING',
  Unapproved: 'UNAPPROVED'
} as const;

export type AccountantStatus = typeof AccountantStatus[keyof typeof AccountantStatus];
/**  Accounting method enum (שיטת חשבונאות)  */
export const AccountingMethod = {
  /** Double-entry (כפולה) */
  DoubleEntry: 'DOUBLE_ENTRY',
  /** Single-entry (חד צידית) */
  SingleEntry: 'SINGLE_ENTRY'
} as const;

export type AccountingMethod = typeof AccountingMethod[keyof typeof AccountingMethod];
/**  Business accounting system enum (הנח''ש של העסק)  */
export const AccountingSystem = {
  /** Computerized (ממוחשב) */
  Computerized: 'COMPUTERIZED',
  /** Manual (ידני) */
  Manual: 'MANUAL'
} as const;

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

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

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

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

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

/**  Represents a business entity managed by an accountant in the system. */
export type AdminBusiness = {
  __typename?: 'AdminBusiness';
  business: LtdFinancialEntity;
  governmentId: Scalars['String']['output'];
  id: Scalars['UUID']['output'];
  name: Scalars['String']['output'];
  registrationDate: Scalars['TimelessDate']['output'];
  /**  Social Security Info  */
  socialSecurityDeductionsId?: Maybe<Scalars['String']['output']>;
  socialSecurityEmployerIds: Array<AnnualId>;
  /**  Tax Advances Info  */
  taxAdvancesAnnualIds: Array<AnnualId>;
  taxAdvancesRates: Array<TaxAdvancesRate>;
  withholdingTaxAnnualIds: Array<AnnualId>;
  /**  Withholding Tax Info  */
  withholdingTaxCompanyId?: Maybe<Scalars['String']['output']>;
};

/**  defines a tag / category for charge arrangement */
export type AdminContextInfo = {
  __typename?: 'AdminContextInfo';
  accumulatedDepreciationTaxCategory?: Maybe<TaxCategory>;
  amexBusiness?: Maybe<Business>;
  balanceCancellationTaxCategory: TaxCategory;
  bankDepositBusiness?: Maybe<Business>;
  bankDepositInterestIncomeTaxCategory?: Maybe<TaxCategory>;
  batchedEmployeesBusiness?: Maybe<Business>;
  batchedFundsBusiness?: Maybe<Business>;
  businessTripTag?: Maybe<Tag>;
  businessTripTaxCategory?: Maybe<TaxCategory>;
  calBusiness?: Maybe<Business>;
  compensationFundExpensesTaxCategory?: Maybe<TaxCategory>;
  dateEstablished?: Maybe<Scalars['TimelessDate']['output']>;
  defaultForeignCurrency: Currency;
  defaultLocalCurrency: Currency;
  defaultTaxCategory: TaxCategory;
  developmentForeignTaxCategory: TaxCategory;
  developmentLocalTaxCategory: TaxCategory;
  discountBusiness?: Maybe<Business>;
  dividendTaxCategory?: Maybe<TaxCategory>;
  dividendWithholdingTaxBusiness?: Maybe<Business>;
  etanaBusiness?: Maybe<Business>;
  etherscanBusiness?: Maybe<Business>;
  exchangeRateRevaluationTaxCategory: TaxCategory;
  exchangeRateTaxCategory: TaxCategory;
  expensesInAdvanceTaxCategory: TaxCategory;
  expensesToPayTaxCategory: TaxCategory;
  feeTaxCategory: TaxCategory;
  fineTaxCategory: TaxCategory;
  foreignSecuritiesBusiness?: Maybe<Business>;
  foreignSecuritiesFeesCategory?: Maybe<TaxCategory>;
  generalFeeTaxCategory: TaxCategory;
  gnmDepreciationExpensesTaxCategory?: Maybe<TaxCategory>;
  id: Scalars['ID']['output'];
  incomeExchangeRateTaxCategory: TaxCategory;
  incomeInAdvanceTaxCategory?: Maybe<TaxCategory>;
  incomeToCollectTaxCategory: TaxCategory;
  initialAccounterYear?: Maybe<Scalars['Int']['output']>;
  inputVatTaxCategory: TaxCategory;
  isracardBusiness?: Maybe<Business>;
  krakenBusiness?: Maybe<Business>;
  ledgerLock?: Maybe<Scalars['TimelessDate']['output']>;
  locality: Scalars['String']['output'];
  marketingDepreciationExpensesTaxCategory?: Maybe<TaxCategory>;
  outputVatTaxCategory: TaxCategory;
  ownerId: Scalars['UUID']['output'];
  pensionFundExpensesTaxCategory?: Maybe<TaxCategory>;
  poalimBusiness?: Maybe<Business>;
  propertyOutputVatTaxCategory?: Maybe<TaxCategory>;
  recoveryReserveExpensesTaxCategory?: Maybe<TaxCategory>;
  recoveryReserveTaxCategory?: Maybe<TaxCategory>;
  rndDepreciationExpensesTaxCategory?: Maybe<TaxCategory>;
  salaryExcessExpensesTaxCategory: TaxCategory;
  salaryExpensesTaxCategory?: Maybe<TaxCategory>;
  socialSecurityBusiness: Business;
  socialSecurityExpensesTaxCategory?: Maybe<TaxCategory>;
  swiftBusiness?: Maybe<Business>;
  taxBusiness: Business;
  taxDeductionsBusiness?: Maybe<Business>;
  taxExpensesTaxCategory: TaxCategory;
  trainingFundExpensesTaxCategory?: Maybe<TaxCategory>;
  untaxableGiftsTaxCategory: TaxCategory;
  vacationReserveExpensesTaxCategory?: Maybe<TaxCategory>;
  vacationReserveTaxCategory?: Maybe<TaxCategory>;
  vatBusiness: Business;
  zkufotExpensesTaxCategory?: Maybe<TaxCategory>;
  zkufotIncomeTaxCategory?: Maybe<TaxCategory>;
};

/**  input variables for updateAdminContext  */
export type AdminContextInput = {
  accumulatedDepreciationTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  amexBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  balanceCancellationTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  bankDepositBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  bankDepositInterestIncomeTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  batchedEmployeesBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  batchedFundsBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  businessTripTagId?: InputMaybe<Scalars['UUID']['input']>;
  businessTripTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  calBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  compensationFundExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  dateEstablished?: InputMaybe<Scalars['TimelessDate']['input']>;
  defaultForeignCurrency?: InputMaybe<Currency>;
  defaultLocalCurrency?: InputMaybe<Currency>;
  defaultTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  developmentForeignTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  developmentLocalTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  discountBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  dividendTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  dividendWithholdingTaxBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  etanaBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  etherscanBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  exchangeRateRevaluationTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  exchangeRateTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  expensesInAdvanceTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  expensesToPayTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  feeTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  fineTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  foreignSecuritiesBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  foreignSecuritiesFeesCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  generalFeeTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  gnmDepreciationExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  incomeExchangeRateTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  incomeInAdvanceTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  incomeToCollectTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  initialAccounterYear?: InputMaybe<Scalars['Int']['input']>;
  inputVatTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  isracardBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  krakenBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  ledgerLock?: InputMaybe<Scalars['TimelessDate']['input']>;
  locality?: InputMaybe<Scalars['String']['input']>;
  marketingDepreciationExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  outputVatTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  ownerId: Scalars['UUID']['input'];
  pensionFundExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  poalimBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  propertyOutputVatTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  recoveryReserveExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  recoveryReserveTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  rndDepreciationExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  salaryExcessExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  salaryExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  socialSecurityBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  socialSecurityExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  swiftBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  taxBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  taxDeductionsBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  taxExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  trainingFundExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  untaxableGiftsTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  vacationReserveExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  vacationReserveTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  vatBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  zkufotExpensesTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
  zkufotIncomeTaxCategoryId?: InputMaybe<Scalars['UUID']['input']>;
};

/**  Input for an American Express credit card transaction  */
export type AmexTransactionInput = {
  adendum?: InputMaybe<Scalars['String']['input']>;
  card: Scalars['String']['input'];
  cardIndex: Scalars['Int']['input'];
  chargingDate?: InputMaybe<Scalars['String']['input']>;
  city?: InputMaybe<Scalars['String']['input']>;
  clientIpAddress?: InputMaybe<Scalars['String']['input']>;
  currencyId?: InputMaybe<Scalars['String']['input']>;
  currentPaymentCurrency?: InputMaybe<Scalars['String']['input']>;
  dealSum?: InputMaybe<Scalars['String']['input']>;
  dealSumOutbound?: InputMaybe<Scalars['String']['input']>;
  dealSumType?: InputMaybe<Scalars['String']['input']>;
  dealsInbound?: InputMaybe<Scalars['String']['input']>;
  displayProperties?: InputMaybe<Scalars['String']['input']>;
  esbServicesCall?: InputMaybe<Scalars['String']['input']>;
  fullPaymentDate?: InputMaybe<Scalars['String']['input']>;
  fullPurchaseDate?: InputMaybe<Scalars['String']['input']>;
  fullPurchaseDateOutbound?: InputMaybe<Scalars['String']['input']>;
  fullSupplierNameHeb?: InputMaybe<Scalars['String']['input']>;
  fullSupplierNameOutbound?: InputMaybe<Scalars['String']['input']>;
  horaatKeva?: InputMaybe<Scalars['String']['input']>;
  isButton: Scalars['String']['input'];
  isCaptcha: Scalars['String']['input'];
  isError: Scalars['String']['input'];
  isHoraatKeva: Scalars['String']['input'];
  isShowDealsOutbound?: InputMaybe<Scalars['String']['input']>;
  isShowLinkForSupplierDetails?: InputMaybe<Scalars['String']['input']>;
  kodMatbeaMekori?: InputMaybe<Scalars['String']['input']>;
  message?: InputMaybe<Scalars['String']['input']>;
  moreInfo?: InputMaybe<Scalars['String']['input']>;
  paymentDate?: InputMaybe<Scalars['String']['input']>;
  paymentSum?: InputMaybe<Scalars['String']['input']>;
  paymentSumOutbound?: InputMaybe<Scalars['String']['input']>;
  paymentSumSign?: InputMaybe<Scalars['String']['input']>;
  purchaseDate?: InputMaybe<Scalars['String']['input']>;
  purchaseDateOutbound?: InputMaybe<Scalars['String']['input']>;
  returnCode?: InputMaybe<Scalars['String']['input']>;
  returnMessage?: InputMaybe<Scalars['String']['input']>;
  siteName?: InputMaybe<Scalars['String']['input']>;
  solek?: InputMaybe<Scalars['String']['input']>;
  specificDate?: InputMaybe<Scalars['String']['input']>;
  stage?: InputMaybe<Scalars['String']['input']>;
  supplierId?: InputMaybe<Scalars['Int']['input']>;
  supplierName?: InputMaybe<Scalars['String']['input']>;
  supplierNameOutbound?: InputMaybe<Scalars['String']['input']>;
  tablePageNum: Scalars['Boolean']['input'];
  voucherNumber?: InputMaybe<Scalars['Int']['input']>;
  voucherNumberRatz?: InputMaybe<Scalars['Int']['input']>;
  voucherNumberRatzOutbound?: InputMaybe<Scalars['Int']['input']>;
};

/**  Result type for annualAuditOpeningBalanceStatus query  */
export type AnnualAuditOpeningBalanceStatusInfo = {
  __typename?: 'AnnualAuditOpeningBalanceStatusInfo';
  /**  Only relevant for MIGRATING users  */
  balanceChargeId?: Maybe<Scalars['UUID']['output']>;
  derivedStatus: AnnualAuditStepStatus;
  errorMessage?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  userType: AnnualAuditOpeningBalanceUserType;
};

/**  User type classification for annual audit opening balance step  */
export const AnnualAuditOpeningBalanceUserType = {
  Continuing: 'CONTINUING',
  Error: 'ERROR',
  Migrating: 'MIGRATING',
  New: 'NEW'
} as const;

export type AnnualAuditOpeningBalanceUserType = typeof AnnualAuditOpeningBalanceUserType[keyof typeof AnnualAuditOpeningBalanceUserType];
/**  Status values for annual audit steps  */
export const AnnualAuditStepStatus = {
  Blocked: 'BLOCKED',
  Completed: 'COMPLETED',
  InProgress: 'IN_PROGRESS',
  Pending: 'PENDING'
} as const;

export type AnnualAuditStepStatus = typeof AnnualAuditStepStatus[keyof typeof AnnualAuditStepStatus];
/**  Persisted manual status for a single annual audit step  */
export type AnnualAuditStepStatusInfo = {
  __typename?: 'AnnualAuditStepStatusInfo';
  completedAt?: Maybe<Scalars['DateTime']['output']>;
  /**  JSON-encoded evidence metadata (step-specific structure)  */
  evidence?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  notes?: Maybe<Scalars['String']['output']>;
  ownerId: Scalars['UUID']['output'];
  status: AnnualAuditStepStatus;
  stepId: Scalars['String']['output'];
  updatedAt: Scalars['DateTime']['output'];
  year: Scalars['Int']['output'];
};

/**  Represents an annual identifier for tax purposes.  */
export type AnnualId = {
  __typename?: 'AnnualId';
  id: Scalars['String']['output'];
  year: Scalars['Int']['output'];
};

/**  Input type representing an annual identifier for tax purposes.  */
export type AnnualIdInput = {
  id: Scalars['String']['input'];
  year: Scalars['Int']['input'];
};

/**  annual revenue report  */
export type AnnualRevenueReport = {
  __typename?: 'AnnualRevenueReport';
  countries: Array<AnnualRevenueReportCountry>;
  id: Scalars['ID']['output'];
  year: Scalars['Int']['output'];
};

/**  annual revenue report country client record  */
export type AnnualRevenueReportClientRecord = {
  __typename?: 'AnnualRevenueReportClientRecord';
  chargeId: Scalars['UUID']['output'];
  date: Scalars['TimelessDate']['output'];
  description?: Maybe<Scalars['String']['output']>;
  id: Scalars['ID']['output'];
  reference?: Maybe<Scalars['String']['output']>;
  revenueDefaultForeign: FinancialAmount;
  revenueLocal: FinancialAmount;
  revenueOriginal: FinancialAmount;
};

/**  annual revenue report country  */
export type AnnualRevenueReportCountry = {
  __typename?: 'AnnualRevenueReportCountry';
  clients: Array<AnnualRevenueReportCountryClient>;
  code: Scalars['String']['output'];
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  revenueDefaultForeign: FinancialAmount;
  revenueLocal: FinancialAmount;
};

/**  annual revenue report country client  */
export type AnnualRevenueReportCountryClient = {
  __typename?: 'AnnualRevenueReportCountryClient';
  id: Scalars['ID']['output'];
  name: Scalars['String']['output'];
  records: Array<AnnualRevenueReportClientRecord>;
  revenueDefaultForeign: FinancialAmount;
  revenueLocal: FinancialAmount;
};

/**  annual revenue report filter  */
export type AnnualRevenueReportFilter = {
  adminBusinessId?: InputMaybe<Scalars['UUID']['input']>;
  year: Scalars['Int']['input'];
};

/**  API key metadata (plaintext key is never stored)  */
export type ApiKey = {
  __typename?: 'ApiKey';
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['ID']['output'];
  lastUsedAt?: Maybe<Scalars['DateTime']['output']>;
  name: Scalars['String']['output'];
  roleId: Scalars['String']['output'];
};

/**  Audit opinion type enum (חוות דעת)  */
export const AuditOpinionType = {
  /** Adverse opinion (שלילית) */
  Adverse: 'ADVERSE',
  /** Disclaimer of opinion (המנעות) */
  Disclaimer: 'DISCLAIMER',
  /** No audit opinion (אין חוות דעת) */
  None: 'NONE',
  /** Qualified opinion (הסתייגות) */
  Qualified: 'QUALIFIED',
  /** Unqualified opinion (נוסח אחיד (בלתי מסוייג)) */
  Unqualified: 'UNQUALIFIED',
  /** Unqualified opinion with emphasis on going concern (בנוסח אחיד עם הפניית תשומת לב להערת עסק חי) */
  UnqualifiedWithGoingConcern: 'UNQUALIFIED_WITH_GOING_CONCERN',
  /** Unqualified opinion with other emphases (בנוסח אחיד עם הפניות תשומת לב אחרת) */
  UnqualifiedWithOtherEmphases: 'UNQUALIFIED_WITH_OTHER_EMPHASES'
} as const;

export type AuditOpinionType = typeof AuditOpinionType[keyof typeof AuditOpinionType];
/**  Result of the auto-match operation  */
export type AutoMatchChargesResult = {
  __typename?: 'AutoMatchChargesResult';
  /**  Array of error messages encountered during the operation  */
  errors: Array<Scalars['String']['output']>;
  /**  Array of charges that were merged, with their confidence scores  */
  mergedCharges: Array<MergedCharge>;
  /**  Array of charge UUIDs that had multiple high-confidence matches and were skipped  */
  skippedCharges: Array<Scalars['UUID']['output']>;
  /**  Total number of charges that were successfully matched and merged  */
  totalMatches: Scalars['Int']['output'];
};

/**  transactions for balance report  */
export type BalanceTransactions = {
  __typename?: 'BalanceTransactions';
  account: FinancialAccount;
  amount: FinancialAmount;
  amountUsd: FinancialAmount;
  charge: Charge;
  chargeId: Scalars['UUID']['output'];
  counterparty?: Maybe<FinancialEntity>;
  date: Scalars['TimelessDate']['output'];
  description?: Maybe<Scalars['String']['output']>;
  id: Scalars['UUID']['output'];
  isFee: Scalars['Boolean']['output'];
  month: Scalars['Int']['output'];
  year: Scalars['Int']['output'];
};

/**  input type for creating a bank account  */
export type BankAccountInsertInput = {
  accountAgreementOpeningDate?: InputMaybe<Scalars['Int']['input']>;
  accountClosingReasonCode?: InputMaybe<Scalars['Int']['input']>;
  accountDealDate?: InputMaybe<Scalars['Int']['input']>;
  accountUpdateDate?: InputMaybe<Scalars['Int']['input']>;
  bankNumber: Scalars['Int']['input'];
  branchNumber: Scalars['Int']['input'];
  branchTypeCode?: InputMaybe<Scalars['Int']['input']>;
  extendedBankNumber?: InputMaybe<Scalars['Int']['input']>;
  iban?: InputMaybe<Scalars['String']['input']>;
  kodHarshaatPeilut?: InputMaybe<Scalars['Int']['input']>;
  metegDoarNet?: InputMaybe<Scalars['Int']['input']>;
  mymailEntitlementSwitch?: InputMaybe<Scalars['Int']['input']>;
  partyAccountInvolvementCode?: InputMaybe<Scalars['Int']['input']>;
  partyPreferredIndication?: InputMaybe<Scalars['Int']['input']>;
  productLabel?: InputMaybe<Scalars['String']['input']>;
  serviceAuthorizationDesc?: InputMaybe<Scalars['String']['input']>;
  swiftCode?: InputMaybe<Scalars['String']['input']>;
};

/**  input type for updating a bank account  */
export type BankAccountUpdateInput = {
  accountAgreementOpeningDate?: InputMaybe<Scalars['Int']['input']>;
  accountClosingReasonCode?: InputMaybe<Scalars['Int']['input']>;
  accountDealDate?: InputMaybe<Scalars['Int']['input']>;
  accountUpdateDate?: InputMaybe<Scalars['Int']['input']>;
  bankNumber?: InputMaybe<Scalars['Int']['input']>;
  branchNumber?: InputMaybe<Scalars['Int']['input']>;
  branchTypeCode?: InputMaybe<Scalars['Int']['input']>;
  extendedBankNumber?: InputMaybe<Scalars['Int']['input']>;
  iban?: InputMaybe<Scalars['String']['input']>;
  kodHarshaatPeilut?: InputMaybe<Scalars['Int']['input']>;
  metegDoarNet?: InputMaybe<Scalars['Int']['input']>;
  mymailEntitlementSwitch?: InputMaybe<Scalars['Int']['input']>;
  partyAccountInvolvementCode?: InputMaybe<Scalars['Int']['input']>;
  partyPreferredIndication?: InputMaybe<Scalars['Int']['input']>;
  productLabel?: InputMaybe<Scalars['String']['input']>;
  serviceAuthorizationDesc?: InputMaybe<Scalars['String']['input']>;
  swiftCode?: InputMaybe<Scalars['String']['input']>;
};

/**  Bank Deposit  */
export type BankDeposit = {
  __typename?: 'BankDeposit';
  account?: Maybe<FinancialAccount>;
  closeDate?: Maybe<Scalars['TimelessDate']['output']>;
  currency?: Maybe<Currency>;
  id: Scalars['ID']['output'];
  isOpen: Scalars['Boolean']['output'];
  metadata: BankDepositMetadata;
  name: Scalars['String']['output'];
  openDate?: Maybe<Scalars['TimelessDate']['output']>;
};

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

/**  represent a bank deposit account  */
export type BankDepositFinancialAccount = FinancialAccount & {
  __typename?: 'BankDepositFinancialAccount';
  accountTaxCategories: Array<CurrencyTaxCategory>;
  charges: Array<Charge>;
  id: Scalars['UUID']['output'];
  name: Scalars['String']['output'];
  number: Scalars['String']['output'];
  privateOrBusiness: PrivateOrBusinessType;
  type: FinancialAccountType;
};


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

/**  Metadata for Bank Deposit, including current balance, total interest, total deposit amount, and associated transactions.  */
export type BankDepositMetadata = {
  __typename?: 'BankDepositMetadata';
  currentBalance: FinancialAmount;
  id: Scalars['ID']['output'];
  potentialCloseDate?: Maybe<Scalars['TimelessDate']['output']>;
  totalDeposit: FinancialAmount;
  totalInterest: FinancialAmount;
  transactions: Array<Transaction>;
};

/**  represent a single bank account */
export type BankFinancialAccount = FinancialAccount & {
  __typename?: 'BankFinancialAccount';
  accountAgreementOpeningDate?: Maybe<Scalars['Int']['output']>;
  accountClosingReasonCode?: Maybe<Scalars['Int']['output']>;
  accountDealDate?: Maybe<Scalars['Int']['output']>;
  /**  the external identifier of the bank account  */
  accountNumber: Scalars['String']['output'];
  accountTaxCategories: Array<CurrencyTaxCategory>;
  accountUpdateDate?: Maybe<Scalars['Int']['output']>;
  bankNumber: Scalars['Int']['output'];
  branchNumber: Scalars['Int']['output'];
  branchTypeCode?: Maybe<Scalars['Int']['output']>;
  charges: Array<Charge>;
  extendedBankNumber?: Maybe<Scalars['Int']['output']>;
  iban?: Maybe<Scalars['String']['output']>;
  id: Scalars['UUID']['output'];
  kodHarshaatPeilut?: Maybe<Scalars['Int']['output']>;
  metegDoarNet?: Maybe<Scalars['Int']['output']>;
  mymailEntitlementSwitch?: Maybe<Scalars['Int']['output']>;
  name: Scalars['String']['output'];
  number: Scalars['String']['output'];
  partyAccountInvolvementCode?: Maybe<Scalars['Int']['output']>;
  partyPreferredIndication?: Maybe<Scalars['Int']['output']>;
  privateOrBusiness: PrivateOrBusinessType;
  productLabel?: Maybe<Scalars['String']['output']>;
  serviceAuthorizationDesc?: Maybe<Scalars['String']['output']>;
  swiftCode?: Maybe<Scalars['String']['output']>;
  type: FinancialAccountType;
};


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

/**  result type for batchUpdateCharges  */
export type BatchUpdateChargesResult = BatchUpdateChargesSuccessfulResult | CommonError;

/**  successful result type for batchUpdateCharges  */
export type BatchUpdateChargesSuccessfulResult = {
  __typename?: 'BatchUpdateChargesSuccessfulResult';
  charges: Array<Charge>;
};

/**  contract billing cycle  */
export const BillingCycle = {
  Annual: 'ANNUAL',
  Monthly: 'MONTHLY'
} as const;

export type BillingCycle = typeof BillingCycle[keyof typeof BillingCycle];
/**  input required to bootstrap a new client business and its initial owner  */
export type BootstrapClientInput = {
  businessName: Scalars['String']['input'];
  countryCode: Scalars['String']['input'];
  dateEstablished?: InputMaybe<Scalars['TimelessDate']['input']>;
  initialAccounterYear?: InputMaybe<Scalars['Int']['input']>;
  locality?: InputMaybe<Scalars['String']['input']>;
  ownerEmail: Scalars['String']['input'];
  ownerRole: Scalars['String']['input'];
};

/**  Result returned after bootstrapping, including business, invitation token, and admin context.  */
export type BootstrapClientResult = {
  __typename?: 'BootstrapClientResult';
  adminContext: AdminContextInfo;
  business: Business;
  id: Scalars['ID']['output'];
  invitationToken: Scalars['String']['output'];
};

/**  represent a financial entity of any type that may hold financial accounts (company, business, individual)  */
export type Business = {
  accounts: Array<FinancialAccount>;
  charges: PaginatedCharges;
  createdAt: Scalars['DateTime']['output'];
  id: Scalars['UUID']['output'];
  irsCode?: Maybe<Scalars['Int']['output']>;
  isActive: Scalars['Boolean']['output'];
  name: Scalars['String']['output'];
  pcn874RecordType?: Maybe<Pcn874RecordType>;
  sortCode?: Maybe<SortCode>;
  updatedAt: Scalars['DateTime']['output'];
};


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

/**  configuration for business email processing  */
export type BusinessEmailConfig = {
  __typename?: 'BusinessEmailConfig';
  attachments?: Maybe<Array<EmailAttachmentType>>;
  businessId: Scalars['UUID']['output'];
  emailBody?: Maybe<Scalars['Boolean']['output']>;
  internalEmailLinks?: Maybe<Array<Scalars['String']['output']>>;
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**  represent category type of business trip summary  */
export const BusinessTripExpenseCategories = {
  Accommodation: 'ACCOMMODATION',
  CarRental: 'CAR_RENTAL',
  Flight: 'FLIGHT',
  Other: 'OTHER',
  TravelAndSubsistence: 'TRAVEL_AND_SUBSISTENCE'
} as const;

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

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

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

/**  represent category type of business trip summary  */
export const BusinessTripSummaryCategories = {
  Accommodation: 'ACCOMMODATION',
  CarRental: 'CAR_RENTAL',
  Flight: 'FLIGHT',
  Other: 'OTHER',
  Total: 'TOTAL',
  TravelAndSubsistence: 'TRAVEL_AND_SUBSISTENCE'
} as const;

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

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

/**  Business type enum (סוג עסק)  */
export const BusinessType = {
  /** Combination (שילוב) */
  Combination: 'COMBINATION',
  /** Commercial (מסחרי) */
  Commercial: 'COMMERCIAL',
  /** Industrial (תעשייתי) */
  Industrial: 'INDUSTRIAL',
  /** Report includes more than one business (הדוח כולל יותר מעסק אחד) */
  Multiple: 'MULTIPLE',
  /** Service providers (נותני שירותים) */
  Service: 'SERVICE'
} as const;

export type BusinessType = typeof BusinessType[keyof typeof BusinessType];
/**  Input for a Cal (Visa Cal) credit card transaction  */
export type CalTransactionInput = {
  amtBeforeConvAndIndex?: InputMaybe<Scalars['String']['input']>;
  branchCodeDesc?: InputMaybe<Scalars['String']['input']>;
  card: Scalars['Int']['input'];
  cashAccountTrnAmt?: InputMaybe<Scalars['String']['input']>;
  chargeExternalToCardComment?: InputMaybe<Scalars['String']['input']>;
  crdExtIdNumTypeCode?: InputMaybe<Scalars['String']['input']>;
  curPaymentNum?: InputMaybe<Scalars['Int']['input']>;
  debCrdCurrencySymbol?: InputMaybe<Scalars['String']['input']>;
  debCrdDate?: InputMaybe<Scalars['String']['input']>;
  debitSpreadInd?: InputMaybe<Scalars['Boolean']['input']>;
  earlyPaymentInd?: InputMaybe<Scalars['Boolean']['input']>;
  isAbroadTransaction?: InputMaybe<Scalars['Boolean']['input']>;
  isImmediateCommentInd?: InputMaybe<Scalars['Boolean']['input']>;
  isImmediateHhkInd?: InputMaybe<Scalars['Boolean']['input']>;
  isMargarita?: InputMaybe<Scalars['Boolean']['input']>;
  isSpreadPaymenstAbroad?: InputMaybe<Scalars['Boolean']['input']>;
  merchantAddress?: InputMaybe<Scalars['String']['input']>;
  merchantId?: InputMaybe<Scalars['String']['input']>;
  merchantName?: InputMaybe<Scalars['String']['input']>;
  merchantPhoneNo?: InputMaybe<Scalars['String']['input']>;
  numOfPayments?: InputMaybe<Scalars['Int']['input']>;
  onGoingTransactionsComment?: InputMaybe<Scalars['String']['input']>;
  refundInd?: InputMaybe<Scalars['Boolean']['input']>;
  tokenInd?: InputMaybe<Scalars['Int']['input']>;
  tokenNumberPart4?: InputMaybe<Scalars['String']['input']>;
  transCardPresentInd?: InputMaybe<Scalars['Boolean']['input']>;
  transSource?: InputMaybe<Scalars['String']['input']>;
  trnAmt?: InputMaybe<Scalars['String']['input']>;
  trnCurrencySymbol?: InputMaybe<Scalars['String']['input']>;
  trnExacWay?: InputMaybe<Scalars['Int']['input']>;
  trnIntId?: InputMaybe<Scalars['String']['input']>;
  trnNumaretor?: InputMaybe<Scalars['Int']['input']>;
  trnPurchaseDate?: InputMaybe<Scalars['String']['input']>;
  trnType?: InputMaybe<Scalars['String']['input']>;
  trnTypeCode?: InputMaybe<Scalars['String']['input']>;
  walletProviderCode?: InputMaybe<Scalars['Int']['input']>;
  walletProviderDesc?: InputMaybe<Scalars['String']['input']>;
};

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


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

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

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

/**  A field that changed on an existing row (reserved for future upsert logic)  */
export type ChangedField = {
  __typename?: 'ChangedField';
  field: Scalars['String']['output'];
  newValue?: Maybe<Scalars['String']['output']>;
  oldValue?: Maybe<Scalars['String']['output']>;
};

/**  A transaction row that was updated rather than inserted (reserved for future upsert logic)  */
export type ChangedTransaction = {
  __typename?: 'ChangedTransaction';
  changedFields: Array<ChangedField>;
  id: Scalars['ID']['output'];
};

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

/**  input variables for charge filtering  */
export type ChargeFilter = {
  accountantStatus?: InputMaybe<Array<AccountantStatus>>;
  /**  filter by business trip (should be later in business trip module?)  */
  businessTrip?: InputMaybe<Scalars['UUID']['input']>;
  /**  Include only charges including specific business  */
  byBusinesses?: InputMayb