@accounter/payper-mesh/src/mesh-artifacts/index.ts

Graphql proxy for Payper API

// @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 { PayperTypes } from './sources/Payper/types';
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; }
  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; }
  ObjMap: { input: unknown; output: unknown; }
};

export type Query = {
  getExpensesRaw?: Maybe<getExpensesResponse>;
  getExpenses?: Maybe<getExpensesResponse>;
};


export type QuerygetExpensesRawArgs = {
  input?: InputMaybe<getExpensesRequest_Input>;
};


export type QuerygetExpensesArgs = {
  input?: InputMaybe<getExpensesRequest_Input>;
};

export type getExpensesResponse = {
  description: Scalars['String']['output'];
  /** An array of JSON of the search */
  expenses?: Maybe<Array<Maybe<Expense>>>;
  /** The next available page */
  next_page?: Maybe<Scalars['String']['output']>;
  result: Scalars['Int']['output'];
  /** The total size of the query */
  total_entries?: Maybe<Scalars['Int']['output']>;
  /** The total pages of the query */
  total_pages?: Maybe<Scalars['String']['output']>;
};

/** A Single Expense */
export type Expense = {
  created_at: Scalars['String']['output'];
  currency_symbol?: Maybe<query_getExpensesRaw_expenses_items_currency_symbol>;
  document_date?: Maybe<Scalars['String']['output']>;
  document_id?: Maybe<Scalars['String']['output']>;
  document_type?: Maybe<Scalars['String']['output']>;
  file_name: Scalars['String']['output'];
  file_url: Scalars['String']['output'];
  foreign_total_for_payment?: Maybe<Scalars['Float']['output']>;
  original_file_name?: Maybe<Scalars['String']['output']>;
  provider: Scalars['String']['output'];
  provider_business_num: Scalars['String']['output'];
  recognized_vat_payment: Scalars['Float']['output'];
  remarks?: Maybe<Scalars['String']['output']>;
  status_classification: Scalars['String']['output'];
  system_id: Scalars['Int']['output'];
  total_for_payment: Scalars['Float']['output'];
  total_for_vat: Scalars['Float']['output'];
  updated_at: Scalars['String']['output'];
  vat_payment: Scalars['Float']['output'];
};

export type query_getExpensesRaw_expenses_items_currency_symbol =
  | 'EUR'
  | 'USD'
  | 'ILS';

export type getExpensesRequest_Input = {
  api_user?: InputMaybe<Scalars['String']['input']>;
  query_options?: InputMaybe<queryInput_getExpensesRaw_input_query_options_Input>;
};

export type queryInput_getExpensesRaw_input_query_options_Input = {
  updated_from?: InputMaybe<Scalars['String']['input']>;
  updated_to?: InputMaybe<Scalars['String']['input']>;
  created_from?: InputMaybe<Scalars['String']['input']>;
  created_to?: InputMaybe<Scalars['String']['input']>;
  document_date_from?: InputMaybe<Scalars['String']['input']>;
  document_date_to?: InputMaybe<Scalars['String']['input']>;
  document_id?: InputMaybe<Scalars['String']['input']>;
  /** default: -100000000 */
  system_id?: InputMaybe<Scalars['Int']['input']>;
  order?: InputMaybe<document_date_const>;
  /** default: 1 */
  page?: InputMaybe<Scalars['Int']['input']>;
  /** default: 50 */
  per_page?: InputMaybe<Scalars['Int']['input']>;
};

export type document_date_const =
  | 'document_date';

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

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 between all available schema types and the resolvers types */
export type ResolversTypes = ResolversObject<{
  Query: ResolverTypeWrapper<Record<PropertyKey, never>>;
  getExpensesResponse: ResolverTypeWrapper<getExpensesResponse>;
  Int: ResolverTypeWrapper<Scalars['Int']['output']>;
  Expense: ResolverTypeWrapper<Expense>;
  Float: ResolverTypeWrapper<Scalars['Float']['output']>;
  query_getExpensesRaw_expenses_items_currency_symbol: query_getExpensesRaw_expenses_items_currency_symbol;
  getExpensesRequest_Input: getExpensesRequest_Input;
  queryInput_getExpensesRaw_input_query_options_Input: queryInput_getExpensesRaw_input_query_options_Input;
  document_date_const: document_date_const;
  ObjMap: ResolverTypeWrapper<Scalars['ObjMap']['output']>;
  HTTPMethod: HTTPMethod;
  String: ResolverTypeWrapper<Scalars['String']['output']>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
}>;

/** Mapping between all available schema types and the resolvers parents */
export type ResolversParentTypes = ResolversObject<{
  Query: Record<PropertyKey, never>;
  getExpensesResponse: getExpensesResponse;
  Int: Scalars['Int']['output'];
  Expense: Expense;
  Float: Scalars['Float']['output'];
  getExpensesRequest_Input: getExpensesRequest_Input;
  queryInput_getExpensesRaw_input_query_options_Input: queryInput_getExpensesRaw_input_query_options_Input;
  ObjMap: Scalars['ObjMap']['output'];
  String: Scalars['String']['output'];
  Boolean: Scalars['Boolean']['output'];
}>;

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 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<{
  getExpensesRaw?: Resolver<Maybe<ResolversTypes['getExpensesResponse']>, ParentType, ContextType, Partial<QuerygetExpensesRawArgs>>;
  getExpenses?: Resolver<Maybe<ResolversTypes['getExpensesResponse']>, ParentType, ContextType, Partial<QuerygetExpensesArgs>>;
}>;

export type getExpensesResponseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['getExpensesResponse'] = ResolversParentTypes['getExpensesResponse']> = ResolversObject<{
  description?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  expenses?: Resolver<Maybe<Array<Maybe<ResolversTypes['Expense']>>>, ParentType, ContextType>;
  next_page?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  result?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  total_entries?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
  total_pages?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
}>;

export type ExpenseResolvers<ContextType = MeshContext, ParentType extends ResolversParentTypes['Expense'] = ResolversParentTypes['Expense']> = ResolversObject<{
  created_at?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  currency_symbol?: Resolver<Maybe<ResolversTypes['query_getExpensesRaw_expenses_items_currency_symbol']>, ParentType, ContextType>;
  document_date?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  document_id?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  document_type?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  file_name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  file_url?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  foreign_total_for_payment?: Resolver<Maybe<ResolversTypes['Float']>, ParentType, ContextType>;
  original_file_name?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  provider?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  provider_business_num?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  recognized_vat_payment?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  remarks?: Resolver<Maybe<ResolversTypes['String']>, ParentType, ContextType>;
  status_classification?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  system_id?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
  total_for_payment?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  total_for_vat?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
  updated_at?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
  vat_payment?: Resolver<ResolversTypes['Float'], ParentType, ContextType>;
}>;

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

export type Resolvers<ContextType = MeshContext> = ResolversObject<{
  Query?: QueryResolvers<ContextType>;
  getExpensesResponse?: getExpensesResponseResolvers<ContextType>;
  Expense?: ExpenseResolvers<ContextType>;
  ObjMap?: GraphQLScalarType;
}>;

export type DirectiveResolvers<ContextType = MeshContext> = ResolversObject<{
  enum?: enumDirectiveResolver<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 = PayperTypes.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/Payper/schemaWithAnnotations.js":
      return import("./sources/Payper/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 payperTransforms = [];
const PayperHandler = await import("@graphql-mesh/json-schema").then(handleImport);
const payperHandler = new PayperHandler({
              name: "Payper",
              config: {"endpoint":"https://payper.co.il/app/api","operationHeaders":{"API_KEY":"{context.authToken}","Content-Type":"application/json","Accept":"application/json"},"operations":[{"type":"Query","field":"getExpensesRaw","path":"/pull_expenses","method":"POST","requestSchema":"./json-schemas/payperSchema.json#/definitions/getExpensesRequest","responseSchema":"./json-schemas/payperSchema.json#/definitions/getExpensesResponse"}]},
              baseDir,
              cache,
              pubsub,
              store: sourcesStore.child("Payper"),
              logger: logger.child({ source: "Payper" }),
              importFn,
            });
sources[0] = {
          name: 'Payper',
          handler: payperHandler,
          transforms: payperTransforms
        }
const additionalTypeDefs = [parse("extend type Query {\n  getExpenses(input: getExpensesRequest_Input): getExpensesResponse\n}"),] as any[];
const additionalResolvers = await Promise.all([
        import("../resolvers/get-expenses-resolver.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 getExpensesRaw_queryQueryVariables = Exact<{
  input?: InputMaybe<getExpensesRequest_Input>;
}>;


export type getExpensesRaw_queryQuery = { getExpensesRaw?: Maybe<(
    Pick<
      getExpensesResponse,
      | 'description'
      | 'next_page'
      | 'result'
      | 'total_entries'
      | 'total_pages'
    >
    & { expenses?: Maybe<Array<Maybe<Pick<
        Expense,
        | 'created_at'
        | 'currency_symbol'
        | 'document_date'
        | 'document_id'
        | 'document_type'
        | 'file_name'
        | 'file_url'
        | 'foreign_total_for_payment'
        | 'original_file_name'
        | 'provider'
        | 'provider_business_num'
        | 'recognized_vat_payment'
        | 'remarks'
        | 'status_classification'
        | 'system_id'
        | 'total_for_payment'
        | 'total_for_vat'
        | 'updated_at'
        | 'vat_payment'
      >>>> }
  )> };

export type getExpenses_queryQueryVariables = Exact<{
  input?: InputMaybe<getExpensesRequest_Input>;
}>;


export type getExpenses_queryQuery = { getExpenses?: Maybe<(
    Pick<
      getExpensesResponse,
      | 'description'
      | 'next_page'
      | 'result'
      | 'total_entries'
      | 'total_pages'
    >
    & { expenses?: Maybe<Array<Maybe<Pick<
        Expense,
        | 'created_at'
        | 'currency_symbol'
        | 'document_date'
        | 'document_id'
        | 'document_type'
        | 'file_name'
        | 'file_url'
        | 'foreign_total_for_payment'
        | 'original_file_name'
        | 'provider'
        | 'provider_business_num'
        | 'recognized_vat_payment'
        | 'remarks'
        | 'status_classification'
        | 'system_id'
        | 'total_for_payment'
        | 'total_for_vat'
        | 'updated_at'
        | 'vat_payment'
      >>>> }
  )> };


export const getExpensesRaw_queryDocument = gql`
    query getExpensesRaw_query($input: getExpensesRequest_Input) {
  getExpensesRaw(input: $input) {
    description
    expenses {
      created_at
      currency_symbol
      document_date
      document_id
      document_type
      file_name
      file_url
      foreign_total_for_payment
      original_file_name
      provider
      provider_business_num
      recognized_vat_payment
      remarks
      status_classification
      system_id
      total_for_payment
      total_for_vat
      updated_at
      vat_payment
    }
    next_page
    result
    total_entries
    total_pages
  }
}
    ` as unknown as DocumentNode<getExpensesRaw_queryQuery, getExpensesRaw_queryQueryVariables>;
export const getExpenses_queryDocument = gql`
    query getExpenses_query($input: getExpensesRequest_Input) {
  getExpenses(input: $input) {
    description
    expenses {
      created_at
      currency_symbol
      document_date
      document_id
      document_type
      file_name
      file_url
      foreign_total_for_payment
      original_file_name
      provider
      provider_business_num
      recognized_vat_payment
      remarks
      status_classification
      system_id
      total_for_payment
      total_for_vat
      updated_at
      vat_payment
    }
    next_page
    result
    total_entries
    total_pages
  }
}
    ` as unknown as DocumentNode<getExpenses_queryQuery, getExpenses_queryQueryVariables>;



export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>
export function getSdk<C>(requester: Requester<C>) {
  return {
    getExpensesRaw_query(variables?: getExpensesRaw_queryQueryVariables, options?: C): Promise<getExpensesRaw_queryQuery> {
      return requester<getExpensesRaw_queryQuery, getExpensesRaw_queryQueryVariables>(getExpensesRaw_queryDocument, variables, options) as Promise<getExpensesRaw_queryQuery>;
    },
    getExpenses_query(variables?: getExpenses_queryQueryVariables, options?: C): Promise<getExpenses_queryQuery> {
      return requester<getExpenses_queryQuery, getExpenses_queryQueryVariables>(getExpenses_queryDocument, variables, options) as Promise<getExpenses_queryQuery>;
    }
  };
}
export type Sdk = ReturnType<typeof getSdk>;