@accounter/payper-mesh/.bob/esm/mesh-artifacts/index.d.ts

Graphql proxy for Payper API

import { GraphQLResolveInfo, SelectionSetNode, FieldNode, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
import { TypedDocumentNode as DocumentNode } from '@graphql-typed-document-node/core';
import type { GetMeshOptions } from '@graphql-mesh/runtime';
import type { YamlConfig } from '@graphql-mesh/types';
import { MeshHTTPHandler } from '@graphql-mesh/http';
import { type ExecuteMeshFn, type SubscribeMeshFn, type MeshContext as BaseMeshContext, type MeshInstance } from '@graphql-mesh/runtime';
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;
export declare const rawServeConfig: YamlConfig.Config['serve'];
export declare function getMeshOptions(): Promise<GetMeshOptions>;
export declare function createBuiltMeshHTTPHandler<TServerContext = {}>(): MeshHTTPHandler<TServerContext>;
export declare const pollingInterval: null;
export declare function getBuiltMesh(): Promise<MeshInstance>;
export declare const execute: ExecuteMeshFn;
export declare const subscribe: SubscribeMeshFn;
export declare function getMeshSDK<TGlobalContext = any, TOperationContext = any>(globalContext?: TGlobalContext): {
    getExpensesRaw_query(variables?: getExpensesRaw_queryQueryVariables, options?: TOperationContext | undefined): Promise<getExpensesRaw_queryQuery>;
    getExpenses_query(variables?: getExpenses_queryQueryVariables, options?: TOperationContext | undefined): Promise<getExpenses_queryQuery>;
};
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 declare const getExpensesRaw_queryDocument: DocumentNode<getExpensesRaw_queryQuery, getExpensesRaw_queryQueryVariables>;
export declare const getExpenses_queryDocument: DocumentNode<getExpenses_queryQuery, getExpenses_queryQueryVariables>;
export type Requester<C = {}> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>;
export declare function getSdk<C>(requester: Requester<C>): {
    getExpensesRaw_query(variables?: getExpensesRaw_queryQueryVariables, options?: C): Promise<getExpensesRaw_queryQuery>;
    getExpenses_query(variables?: getExpenses_queryQueryVariables, options?: C): Promise<getExpenses_queryQuery>;
};
export type Sdk = ReturnType<typeof getSdk>;