@clober/v2-sdk 0.0.1-a → 0.0.1-b

package/src/.graphclient/index.ts

@@ -0,0 +1,1695 @@
+// @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 { PubSub } from '@graphql-mesh/utils';
+import { DefaultLogger } from '@graphql-mesh/utils';
+import MeshCache from "@graphql-mesh/cache-localforage";
+import { fetch as fetchFn } from '@whatwg-node/fetch';
+
+import { MeshResolvedSource } from '@graphql-mesh/runtime';
+import { MeshTransform, MeshPlugin } from '@graphql-mesh/types';
+import GraphqlHandler from "@graphql-mesh/graphql"
+import BareMerger from "@graphql-mesh/merger-bare";
+import { printWithCache } from '@graphql-mesh/utils';
+import { createMeshHTTPHandler, MeshHTTPHandler } from '@graphql-mesh/http';
+import { getMesh, ExecuteMeshFn, SubscribeMeshFn, MeshContext as BaseMeshContext, MeshInstance } from '@graphql-mesh/runtime';
+import { MeshStore, FsStoreStorageAdapter } from '@graphql-mesh/store';
+import { path as pathModule } from '@graphql-mesh/cross-helpers';
+import { ImportFn } from '@graphql-mesh/types';
+import type { CloberV2Types } from './sources/clober-v2/types';
+import * as importedModule$0 from "./sources/clober-v2/introspectionSchema";
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+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 RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+
+
+
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  BigDecimal: any;
+  BigInt: any;
+  Bytes: any;
+  Int8: any;
+};
+
+export type BlockChangedFilter = {
+  number_gte: Scalars['Int'];
+};
+
+export type Block_height = {
+  hash?: InputMaybe<Scalars['Bytes']>;
+  number?: InputMaybe<Scalars['Int']>;
+  number_gte?: InputMaybe<Scalars['Int']>;
+};
+
+export type Book = {
+  id: Scalars['ID'];
+  base: Token;
+  quote: Token;
+  unit: Scalars['BigInt'];
+  makerPolicy: Scalars['BigInt'];
+  takerPolicy: Scalars['BigInt'];
+  hooks: Scalars['String'];
+  depths: Array<Depth>;
+  openOrders: Array<OpenOrder>;
+  latestTick: Scalars['BigInt'];
+  latestPrice: Scalars['BigInt'];
+  latestTimestamp: Scalars['BigInt'];
+};
+
+
+export type BookdepthsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Depth_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Depth_filter>;
+};
+
+
+export type BookopenOrdersArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<OpenOrder_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<OpenOrder_filter>;
+};
+
+export type Book_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  base?: InputMaybe<Scalars['String']>;
+  base_not?: InputMaybe<Scalars['String']>;
+  base_gt?: InputMaybe<Scalars['String']>;
+  base_lt?: InputMaybe<Scalars['String']>;
+  base_gte?: InputMaybe<Scalars['String']>;
+  base_lte?: InputMaybe<Scalars['String']>;
+  base_in?: InputMaybe<Array<Scalars['String']>>;
+  base_not_in?: InputMaybe<Array<Scalars['String']>>;
+  base_contains?: InputMaybe<Scalars['String']>;
+  base_contains_nocase?: InputMaybe<Scalars['String']>;
+  base_not_contains?: InputMaybe<Scalars['String']>;
+  base_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  base_starts_with?: InputMaybe<Scalars['String']>;
+  base_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  base_not_starts_with?: InputMaybe<Scalars['String']>;
+  base_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  base_ends_with?: InputMaybe<Scalars['String']>;
+  base_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  base_not_ends_with?: InputMaybe<Scalars['String']>;
+  base_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  base_?: InputMaybe<Token_filter>;
+  quote?: InputMaybe<Scalars['String']>;
+  quote_not?: InputMaybe<Scalars['String']>;
+  quote_gt?: InputMaybe<Scalars['String']>;
+  quote_lt?: InputMaybe<Scalars['String']>;
+  quote_gte?: InputMaybe<Scalars['String']>;
+  quote_lte?: InputMaybe<Scalars['String']>;
+  quote_in?: InputMaybe<Array<Scalars['String']>>;
+  quote_not_in?: InputMaybe<Array<Scalars['String']>>;
+  quote_contains?: InputMaybe<Scalars['String']>;
+  quote_contains_nocase?: InputMaybe<Scalars['String']>;
+  quote_not_contains?: InputMaybe<Scalars['String']>;
+  quote_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  quote_starts_with?: InputMaybe<Scalars['String']>;
+  quote_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  quote_not_starts_with?: InputMaybe<Scalars['String']>;
+  quote_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  quote_ends_with?: InputMaybe<Scalars['String']>;
+  quote_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  quote_not_ends_with?: InputMaybe<Scalars['String']>;
+  quote_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  quote_?: InputMaybe<Token_filter>;
+  unit?: InputMaybe<Scalars['BigInt']>;
+  unit_not?: InputMaybe<Scalars['BigInt']>;
+  unit_gt?: InputMaybe<Scalars['BigInt']>;
+  unit_lt?: InputMaybe<Scalars['BigInt']>;
+  unit_gte?: InputMaybe<Scalars['BigInt']>;
+  unit_lte?: InputMaybe<Scalars['BigInt']>;
+  unit_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  unit_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  makerPolicy?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_not?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_gt?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_lt?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_gte?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_lte?: InputMaybe<Scalars['BigInt']>;
+  makerPolicy_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  makerPolicy_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  takerPolicy?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_not?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_gt?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_lt?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_gte?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_lte?: InputMaybe<Scalars['BigInt']>;
+  takerPolicy_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  takerPolicy_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  hooks?: InputMaybe<Scalars['String']>;
+  hooks_not?: InputMaybe<Scalars['String']>;
+  hooks_gt?: InputMaybe<Scalars['String']>;
+  hooks_lt?: InputMaybe<Scalars['String']>;
+  hooks_gte?: InputMaybe<Scalars['String']>;
+  hooks_lte?: InputMaybe<Scalars['String']>;
+  hooks_in?: InputMaybe<Array<Scalars['String']>>;
+  hooks_not_in?: InputMaybe<Array<Scalars['String']>>;
+  hooks_contains?: InputMaybe<Scalars['String']>;
+  hooks_contains_nocase?: InputMaybe<Scalars['String']>;
+  hooks_not_contains?: InputMaybe<Scalars['String']>;
+  hooks_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  hooks_starts_with?: InputMaybe<Scalars['String']>;
+  hooks_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  hooks_not_starts_with?: InputMaybe<Scalars['String']>;
+  hooks_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  hooks_ends_with?: InputMaybe<Scalars['String']>;
+  hooks_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  hooks_not_ends_with?: InputMaybe<Scalars['String']>;
+  hooks_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  depths_?: InputMaybe<Depth_filter>;
+  openOrders_?: InputMaybe<OpenOrder_filter>;
+  latestTick?: InputMaybe<Scalars['BigInt']>;
+  latestTick_not?: InputMaybe<Scalars['BigInt']>;
+  latestTick_gt?: InputMaybe<Scalars['BigInt']>;
+  latestTick_lt?: InputMaybe<Scalars['BigInt']>;
+  latestTick_gte?: InputMaybe<Scalars['BigInt']>;
+  latestTick_lte?: InputMaybe<Scalars['BigInt']>;
+  latestTick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestTick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestPrice?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_not?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_gt?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_lt?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_gte?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_lte?: InputMaybe<Scalars['BigInt']>;
+  latestPrice_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestPrice_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestTimestamp?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_not?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  latestTimestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Book_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<Book_filter>>>;
+};
+
+export type Book_orderBy =
+  | 'id'
+  | 'base'
+  | 'base__id'
+  | 'base__symbol'
+  | 'base__name'
+  | 'base__decimals'
+  | 'quote'
+  | 'quote__id'
+  | 'quote__symbol'
+  | 'quote__name'
+  | 'quote__decimals'
+  | 'unit'
+  | 'makerPolicy'
+  | 'takerPolicy'
+  | 'hooks'
+  | 'depths'
+  | 'openOrders'
+  | 'latestTick'
+  | 'latestPrice'
+  | 'latestTimestamp';
+
+export type ChartLog = {
+  id: Scalars['ID'];
+  marketCode: Scalars['String'];
+  intervalType: Scalars['String'];
+  timestamp: Scalars['BigInt'];
+  open: Scalars['BigDecimal'];
+  high: Scalars['BigDecimal'];
+  low: Scalars['BigDecimal'];
+  close: Scalars['BigDecimal'];
+  baseVolume: Scalars['BigDecimal'];
+};
+
+export type ChartLog_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  marketCode?: InputMaybe<Scalars['String']>;
+  marketCode_not?: InputMaybe<Scalars['String']>;
+  marketCode_gt?: InputMaybe<Scalars['String']>;
+  marketCode_lt?: InputMaybe<Scalars['String']>;
+  marketCode_gte?: InputMaybe<Scalars['String']>;
+  marketCode_lte?: InputMaybe<Scalars['String']>;
+  marketCode_in?: InputMaybe<Array<Scalars['String']>>;
+  marketCode_not_in?: InputMaybe<Array<Scalars['String']>>;
+  marketCode_contains?: InputMaybe<Scalars['String']>;
+  marketCode_contains_nocase?: InputMaybe<Scalars['String']>;
+  marketCode_not_contains?: InputMaybe<Scalars['String']>;
+  marketCode_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  marketCode_starts_with?: InputMaybe<Scalars['String']>;
+  marketCode_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  marketCode_not_starts_with?: InputMaybe<Scalars['String']>;
+  marketCode_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  marketCode_ends_with?: InputMaybe<Scalars['String']>;
+  marketCode_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  marketCode_not_ends_with?: InputMaybe<Scalars['String']>;
+  marketCode_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  intervalType?: InputMaybe<Scalars['String']>;
+  intervalType_not?: InputMaybe<Scalars['String']>;
+  intervalType_gt?: InputMaybe<Scalars['String']>;
+  intervalType_lt?: InputMaybe<Scalars['String']>;
+  intervalType_gte?: InputMaybe<Scalars['String']>;
+  intervalType_lte?: InputMaybe<Scalars['String']>;
+  intervalType_in?: InputMaybe<Array<Scalars['String']>>;
+  intervalType_not_in?: InputMaybe<Array<Scalars['String']>>;
+  intervalType_contains?: InputMaybe<Scalars['String']>;
+  intervalType_contains_nocase?: InputMaybe<Scalars['String']>;
+  intervalType_not_contains?: InputMaybe<Scalars['String']>;
+  intervalType_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  intervalType_starts_with?: InputMaybe<Scalars['String']>;
+  intervalType_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  intervalType_not_starts_with?: InputMaybe<Scalars['String']>;
+  intervalType_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  intervalType_ends_with?: InputMaybe<Scalars['String']>;
+  intervalType_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  intervalType_not_ends_with?: InputMaybe<Scalars['String']>;
+  intervalType_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  open?: InputMaybe<Scalars['BigDecimal']>;
+  open_not?: InputMaybe<Scalars['BigDecimal']>;
+  open_gt?: InputMaybe<Scalars['BigDecimal']>;
+  open_lt?: InputMaybe<Scalars['BigDecimal']>;
+  open_gte?: InputMaybe<Scalars['BigDecimal']>;
+  open_lte?: InputMaybe<Scalars['BigDecimal']>;
+  open_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high?: InputMaybe<Scalars['BigDecimal']>;
+  high_not?: InputMaybe<Scalars['BigDecimal']>;
+  high_gt?: InputMaybe<Scalars['BigDecimal']>;
+  high_lt?: InputMaybe<Scalars['BigDecimal']>;
+  high_gte?: InputMaybe<Scalars['BigDecimal']>;
+  high_lte?: InputMaybe<Scalars['BigDecimal']>;
+  high_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low?: InputMaybe<Scalars['BigDecimal']>;
+  low_not?: InputMaybe<Scalars['BigDecimal']>;
+  low_gt?: InputMaybe<Scalars['BigDecimal']>;
+  low_lt?: InputMaybe<Scalars['BigDecimal']>;
+  low_gte?: InputMaybe<Scalars['BigDecimal']>;
+  low_lte?: InputMaybe<Scalars['BigDecimal']>;
+  low_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close?: InputMaybe<Scalars['BigDecimal']>;
+  close_not?: InputMaybe<Scalars['BigDecimal']>;
+  close_gt?: InputMaybe<Scalars['BigDecimal']>;
+  close_lt?: InputMaybe<Scalars['BigDecimal']>;
+  close_gte?: InputMaybe<Scalars['BigDecimal']>;
+  close_lte?: InputMaybe<Scalars['BigDecimal']>;
+  close_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  baseVolume?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_not?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_gt?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_lt?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_gte?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_lte?: InputMaybe<Scalars['BigDecimal']>;
+  baseVolume_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  baseVolume_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<ChartLog_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<ChartLog_filter>>>;
+};
+
+export type ChartLog_orderBy =
+  | 'id'
+  | 'marketCode'
+  | 'intervalType'
+  | 'timestamp'
+  | 'open'
+  | 'high'
+  | 'low'
+  | 'close'
+  | 'baseVolume';
+
+export type Depth = {
+  id: Scalars['ID'];
+  book: Book;
+  tick: Scalars['BigInt'];
+  price: Scalars['BigInt'];
+  rawAmount: Scalars['BigInt'];
+  baseAmount: Scalars['BigInt'];
+  quoteAmount: Scalars['BigInt'];
+  latestTakenOrderIndex: Scalars['BigInt'];
+};
+
+export type Depth_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  book?: InputMaybe<Scalars['String']>;
+  book_not?: InputMaybe<Scalars['String']>;
+  book_gt?: InputMaybe<Scalars['String']>;
+  book_lt?: InputMaybe<Scalars['String']>;
+  book_gte?: InputMaybe<Scalars['String']>;
+  book_lte?: InputMaybe<Scalars['String']>;
+  book_in?: InputMaybe<Array<Scalars['String']>>;
+  book_not_in?: InputMaybe<Array<Scalars['String']>>;
+  book_contains?: InputMaybe<Scalars['String']>;
+  book_contains_nocase?: InputMaybe<Scalars['String']>;
+  book_not_contains?: InputMaybe<Scalars['String']>;
+  book_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  book_starts_with?: InputMaybe<Scalars['String']>;
+  book_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  book_not_starts_with?: InputMaybe<Scalars['String']>;
+  book_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  book_ends_with?: InputMaybe<Scalars['String']>;
+  book_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  book_not_ends_with?: InputMaybe<Scalars['String']>;
+  book_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  book_?: InputMaybe<Book_filter>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  price?: InputMaybe<Scalars['BigInt']>;
+  price_not?: InputMaybe<Scalars['BigInt']>;
+  price_gt?: InputMaybe<Scalars['BigInt']>;
+  price_lt?: InputMaybe<Scalars['BigInt']>;
+  price_gte?: InputMaybe<Scalars['BigInt']>;
+  price_lte?: InputMaybe<Scalars['BigInt']>;
+  price_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  price_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawAmount?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseAmount?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestTakenOrderIndex?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_not?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  latestTakenOrderIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  latestTakenOrderIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Depth_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<Depth_filter>>>;
+};
+
+export type Depth_orderBy =
+  | 'id'
+  | 'book'
+  | 'book__id'
+  | 'book__unit'
+  | 'book__makerPolicy'
+  | 'book__takerPolicy'
+  | 'book__hooks'
+  | 'book__latestTick'
+  | 'book__latestPrice'
+  | 'book__latestTimestamp'
+  | 'tick'
+  | 'price'
+  | 'rawAmount'
+  | 'baseAmount'
+  | 'quoteAmount'
+  | 'latestTakenOrderIndex';
+
+export type OpenOrder = {
+  id: Scalars['ID'];
+  book: Book;
+  tick: Scalars['BigInt'];
+  orderIndex: Scalars['BigInt'];
+  price: Scalars['BigInt'];
+  user: Scalars['String'];
+  txHash: Scalars['String'];
+  createdAt: Scalars['BigInt'];
+  rawAmount: Scalars['BigInt'];
+  baseAmount: Scalars['BigInt'];
+  quoteAmount: Scalars['BigInt'];
+  rawFilledAmount: Scalars['BigInt'];
+  baseFilledAmount: Scalars['BigInt'];
+  quoteFilledAmount: Scalars['BigInt'];
+  rawClaimedAmount: Scalars['BigInt'];
+  baseClaimedAmount: Scalars['BigInt'];
+  quoteClaimedAmount: Scalars['BigInt'];
+  rawClaimableAmount: Scalars['BigInt'];
+  baseClaimableAmount: Scalars['BigInt'];
+  quoteClaimableAmount: Scalars['BigInt'];
+  rawOpenAmount: Scalars['BigInt'];
+  baseOpenAmount: Scalars['BigInt'];
+  quoteOpenAmount: Scalars['BigInt'];
+};
+
+export type OpenOrder_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  book?: InputMaybe<Scalars['String']>;
+  book_not?: InputMaybe<Scalars['String']>;
+  book_gt?: InputMaybe<Scalars['String']>;
+  book_lt?: InputMaybe<Scalars['String']>;
+  book_gte?: InputMaybe<Scalars['String']>;
+  book_lte?: InputMaybe<Scalars['String']>;
+  book_in?: InputMaybe<Array<Scalars['String']>>;
+  book_not_in?: InputMaybe<Array<Scalars['String']>>;
+  book_contains?: InputMaybe<Scalars['String']>;
+  book_contains_nocase?: InputMaybe<Scalars['String']>;
+  book_not_contains?: InputMaybe<Scalars['String']>;
+  book_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  book_starts_with?: InputMaybe<Scalars['String']>;
+  book_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  book_not_starts_with?: InputMaybe<Scalars['String']>;
+  book_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  book_ends_with?: InputMaybe<Scalars['String']>;
+  book_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  book_not_ends_with?: InputMaybe<Scalars['String']>;
+  book_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  book_?: InputMaybe<Book_filter>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  orderIndex?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_not?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  orderIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  orderIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  price?: InputMaybe<Scalars['BigInt']>;
+  price_not?: InputMaybe<Scalars['BigInt']>;
+  price_gt?: InputMaybe<Scalars['BigInt']>;
+  price_lt?: InputMaybe<Scalars['BigInt']>;
+  price_gte?: InputMaybe<Scalars['BigInt']>;
+  price_lte?: InputMaybe<Scalars['BigInt']>;
+  price_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  price_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  user?: InputMaybe<Scalars['String']>;
+  user_not?: InputMaybe<Scalars['String']>;
+  user_gt?: InputMaybe<Scalars['String']>;
+  user_lt?: InputMaybe<Scalars['String']>;
+  user_gte?: InputMaybe<Scalars['String']>;
+  user_lte?: InputMaybe<Scalars['String']>;
+  user_in?: InputMaybe<Array<Scalars['String']>>;
+  user_not_in?: InputMaybe<Array<Scalars['String']>>;
+  user_contains?: InputMaybe<Scalars['String']>;
+  user_contains_nocase?: InputMaybe<Scalars['String']>;
+  user_not_contains?: InputMaybe<Scalars['String']>;
+  user_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  user_starts_with?: InputMaybe<Scalars['String']>;
+  user_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  user_not_starts_with?: InputMaybe<Scalars['String']>;
+  user_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  user_ends_with?: InputMaybe<Scalars['String']>;
+  user_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  user_not_ends_with?: InputMaybe<Scalars['String']>;
+  user_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  txHash?: InputMaybe<Scalars['String']>;
+  txHash_not?: InputMaybe<Scalars['String']>;
+  txHash_gt?: InputMaybe<Scalars['String']>;
+  txHash_lt?: InputMaybe<Scalars['String']>;
+  txHash_gte?: InputMaybe<Scalars['String']>;
+  txHash_lte?: InputMaybe<Scalars['String']>;
+  txHash_in?: InputMaybe<Array<Scalars['String']>>;
+  txHash_not_in?: InputMaybe<Array<Scalars['String']>>;
+  txHash_contains?: InputMaybe<Scalars['String']>;
+  txHash_contains_nocase?: InputMaybe<Scalars['String']>;
+  txHash_not_contains?: InputMaybe<Scalars['String']>;
+  txHash_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  txHash_starts_with?: InputMaybe<Scalars['String']>;
+  txHash_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  txHash_not_starts_with?: InputMaybe<Scalars['String']>;
+  txHash_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  txHash_ends_with?: InputMaybe<Scalars['String']>;
+  txHash_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  txHash_not_ends_with?: InputMaybe<Scalars['String']>;
+  txHash_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  createdAt?: InputMaybe<Scalars['BigInt']>;
+  createdAt_not?: InputMaybe<Scalars['BigInt']>;
+  createdAt_gt?: InputMaybe<Scalars['BigInt']>;
+  createdAt_lt?: InputMaybe<Scalars['BigInt']>;
+  createdAt_gte?: InputMaybe<Scalars['BigInt']>;
+  createdAt_lte?: InputMaybe<Scalars['BigInt']>;
+  createdAt_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAt_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawAmount?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseAmount?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawFilledAmount?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawFilledAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawFilledAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseFilledAmount?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseFilledAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseFilledAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteFilledAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteFilledAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteFilledAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawClaimedAmount?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawClaimedAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawClaimedAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseClaimedAmount?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseClaimedAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseClaimedAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteClaimedAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimedAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteClaimedAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawClaimableAmount?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawClaimableAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawClaimableAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseClaimableAmount?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseClaimableAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseClaimableAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteClaimableAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteClaimableAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteClaimableAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawOpenAmount?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_not?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  rawOpenAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  rawOpenAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseOpenAmount?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_not?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  baseOpenAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  baseOpenAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteOpenAmount?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_not?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_gt?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_lt?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_gte?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_lte?: InputMaybe<Scalars['BigInt']>;
+  quoteOpenAmount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  quoteOpenAmount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<OpenOrder_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<OpenOrder_filter>>>;
+};
+
+export type OpenOrder_orderBy =
+  | 'id'
+  | 'book'
+  | 'book__id'
+  | 'book__unit'
+  | 'book__makerPolicy'
+  | 'book__takerPolicy'
+  | 'book__hooks'
+  | 'book__latestTick'
+  | 'book__latestPrice'
+  | 'book__latestTimestamp'
+  | 'tick'
+  | 'orderIndex'
+  | 'price'
+  | 'user'
+  | 'txHash'
+  | 'createdAt'
+  | 'rawAmount'
+  | 'baseAmount'
+  | 'quoteAmount'
+  | 'rawFilledAmount'
+  | 'baseFilledAmount'
+  | 'quoteFilledAmount'
+  | 'rawClaimedAmount'
+  | 'baseClaimedAmount'
+  | 'quoteClaimedAmount'
+  | 'rawClaimableAmount'
+  | 'baseClaimableAmount'
+  | 'quoteClaimableAmount'
+  | 'rawOpenAmount'
+  | 'baseOpenAmount'
+  | 'quoteOpenAmount';
+
+/** Defines the order direction, either ascending or descending */
+export type OrderDirection =
+  | 'asc'
+  | 'desc';
+
+export type Query = {
+  token?: Maybe<Token>;
+  tokens: Array<Token>;
+  book?: Maybe<Book>;
+  books: Array<Book>;
+  depth?: Maybe<Depth>;
+  depths: Array<Depth>;
+  openOrder?: Maybe<OpenOrder>;
+  openOrders: Array<OpenOrder>;
+  chartLog?: Maybe<ChartLog>;
+  chartLogs: Array<ChartLog>;
+  /** Access to subgraph metadata */
+  _meta?: Maybe<_Meta_>;
+};
+
+
+export type QuerytokenArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerytokensArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Token_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Token_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerybookArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerybooksArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Book_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Book_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerydepthArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerydepthsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Depth_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Depth_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryopenOrderArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryopenOrdersArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<OpenOrder_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<OpenOrder_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerychartLogArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerychartLogsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<ChartLog_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<ChartLog_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type Query_metaArgs = {
+  block?: InputMaybe<Block_height>;
+};
+
+export type Subscription = {
+  token?: Maybe<Token>;
+  tokens: Array<Token>;
+  book?: Maybe<Book>;
+  books: Array<Book>;
+  depth?: Maybe<Depth>;
+  depths: Array<Depth>;
+  openOrder?: Maybe<OpenOrder>;
+  openOrders: Array<OpenOrder>;
+  chartLog?: Maybe<ChartLog>;
+  chartLogs: Array<ChartLog>;
+  /** Access to subgraph metadata */
+  _meta?: Maybe<_Meta_>;
+};
+
+
+export type SubscriptiontokenArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptiontokensArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Token_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Token_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionbookArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionbooksArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Book_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Book_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptiondepthArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptiondepthsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Depth_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<Depth_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionopenOrderArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionopenOrdersArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<OpenOrder_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<OpenOrder_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionchartLogArgs = {
+  id: Scalars['ID'];
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionchartLogsArgs = {
+  skip?: InputMaybe<Scalars['Int']>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<ChartLog_orderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  where?: InputMaybe<ChartLog_filter>;
+  block?: InputMaybe<Block_height>;
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type Subscription_metaArgs = {
+  block?: InputMaybe<Block_height>;
+};
+
+export type Token = {
+  id: Scalars['ID'];
+  symbol: Scalars['String'];
+  name: Scalars['String'];
+  decimals: Scalars['BigInt'];
+};
+
+export type Token_filter = {
+  id?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  symbol?: InputMaybe<Scalars['String']>;
+  symbol_not?: InputMaybe<Scalars['String']>;
+  symbol_gt?: InputMaybe<Scalars['String']>;
+  symbol_lt?: InputMaybe<Scalars['String']>;
+  symbol_gte?: InputMaybe<Scalars['String']>;
+  symbol_lte?: InputMaybe<Scalars['String']>;
+  symbol_in?: InputMaybe<Array<Scalars['String']>>;
+  symbol_not_in?: InputMaybe<Array<Scalars['String']>>;
+  symbol_contains?: InputMaybe<Scalars['String']>;
+  symbol_contains_nocase?: InputMaybe<Scalars['String']>;
+  symbol_not_contains?: InputMaybe<Scalars['String']>;
+  symbol_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  symbol_starts_with?: InputMaybe<Scalars['String']>;
+  symbol_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_not_starts_with?: InputMaybe<Scalars['String']>;
+  symbol_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_ends_with?: InputMaybe<Scalars['String']>;
+  symbol_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_not_ends_with?: InputMaybe<Scalars['String']>;
+  symbol_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  name?: InputMaybe<Scalars['String']>;
+  name_not?: InputMaybe<Scalars['String']>;
+  name_gt?: InputMaybe<Scalars['String']>;
+  name_lt?: InputMaybe<Scalars['String']>;
+  name_gte?: InputMaybe<Scalars['String']>;
+  name_lte?: InputMaybe<Scalars['String']>;
+  name_in?: InputMaybe<Array<Scalars['String']>>;
+  name_not_in?: InputMaybe<Array<Scalars['String']>>;
+  name_contains?: InputMaybe<Scalars['String']>;
+  name_contains_nocase?: InputMaybe<Scalars['String']>;
+  name_not_contains?: InputMaybe<Scalars['String']>;
+  name_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  name_starts_with?: InputMaybe<Scalars['String']>;
+  name_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  name_not_starts_with?: InputMaybe<Scalars['String']>;
+  name_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  name_ends_with?: InputMaybe<Scalars['String']>;
+  name_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  name_not_ends_with?: InputMaybe<Scalars['String']>;
+  name_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  decimals?: InputMaybe<Scalars['BigInt']>;
+  decimals_not?: InputMaybe<Scalars['BigInt']>;
+  decimals_gt?: InputMaybe<Scalars['BigInt']>;
+  decimals_lt?: InputMaybe<Scalars['BigInt']>;
+  decimals_gte?: InputMaybe<Scalars['BigInt']>;
+  decimals_lte?: InputMaybe<Scalars['BigInt']>;
+  decimals_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  decimals_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Token_filter>>>;
+  or?: InputMaybe<Array<InputMaybe<Token_filter>>>;
+};
+
+export type Token_orderBy =
+  | 'id'
+  | 'symbol'
+  | 'name'
+  | 'decimals';
+
+export type _Block_ = {
+  /** The hash of the block */
+  hash?: Maybe<Scalars['Bytes']>;
+  /** The block number */
+  number: Scalars['Int'];
+  /** Integer representation of the timestamp stored in blocks for the chain */
+  timestamp?: Maybe<Scalars['Int']>;
+};
+
+/** The type for the top-level _meta field */
+export type _Meta_ = {
+  /**
+   * Information about a specific subgraph block. The hash of the block
+   * will be null if the _meta field has a block constraint that asks for
+   * a block number. It will be filled if the _meta field has no block constraint
+   * and therefore asks for the latest  block
+   *
+   */
+  block: _Block_;
+  /** The deployment ID */
+  deployment: Scalars['String'];
+  /** If `true`, the subgraph encountered indexing errors at some past block */
+  hasIndexingErrors: Scalars['Boolean'];
+};
+
+export type _SubgraphErrorPolicy_ =
+  /** Data will be returned even if the subgraph has indexing errors */
+  | 'allow'
+  /** If the subgraph has indexing errors, data will be omitted. The default. */
+  | 'deny';
+
+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 = {}, TContext = {}, TArgs = {}> =
+  | 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 = {}, TContext = {}, TArgs = {}> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+
+export type NextResolverFn<T> = () => Promise<T>;
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  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<{
+  BigDecimal: ResolverTypeWrapper<Scalars['BigDecimal']>;
+  BigInt: ResolverTypeWrapper<Scalars['BigInt']>;
+  BlockChangedFilter: BlockChangedFilter;
+  Block_height: Block_height;
+  Book: ResolverTypeWrapper<Book>;
+  Book_filter: Book_filter;
+  Book_orderBy: Book_orderBy;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Bytes: ResolverTypeWrapper<Scalars['Bytes']>;
+  ChartLog: ResolverTypeWrapper<ChartLog>;
+  ChartLog_filter: ChartLog_filter;
+  ChartLog_orderBy: ChartLog_orderBy;
+  Depth: ResolverTypeWrapper<Depth>;
+  Depth_filter: Depth_filter;
+  Depth_orderBy: Depth_orderBy;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  Int8: ResolverTypeWrapper<Scalars['Int8']>;
+  OpenOrder: ResolverTypeWrapper<OpenOrder>;
+  OpenOrder_filter: OpenOrder_filter;
+  OpenOrder_orderBy: OpenOrder_orderBy;
+  OrderDirection: OrderDirection;
+  Query: ResolverTypeWrapper<{}>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Subscription: ResolverTypeWrapper<{}>;
+  Token: ResolverTypeWrapper<Token>;
+  Token_filter: Token_filter;
+  Token_orderBy: Token_orderBy;
+  _Block_: ResolverTypeWrapper<_Block_>;
+  _Meta_: ResolverTypeWrapper<_Meta_>;
+  _SubgraphErrorPolicy_: _SubgraphErrorPolicy_;
+}>;
+
+/** Mapping between all available schema types and the resolvers parents */
+export type ResolversParentTypes = ResolversObject<{
+  BigDecimal: Scalars['BigDecimal'];
+  BigInt: Scalars['BigInt'];
+  BlockChangedFilter: BlockChangedFilter;
+  Block_height: Block_height;
+  Book: Book;
+  Book_filter: Book_filter;
+  Boolean: Scalars['Boolean'];
+  Bytes: Scalars['Bytes'];
+  ChartLog: ChartLog;
+  ChartLog_filter: ChartLog_filter;
+  Depth: Depth;
+  Depth_filter: Depth_filter;
+  Float: Scalars['Float'];
+  ID: Scalars['ID'];
+  Int: Scalars['Int'];
+  Int8: Scalars['Int8'];
+  OpenOrder: OpenOrder;
+  OpenOrder_filter: OpenOrder_filter;
+  Query: {};
+  String: Scalars['String'];
+  Subscription: {};
+  Token: Token;
+  Token_filter: Token_filter;
+  _Block_: _Block_;
+  _Meta_: _Meta_;
+}>;
+
+export type entityDirectiveArgs = { };
+
+export type entityDirectiveResolver<Result, Parent, ContextType = MeshContext & { url: string }, Args = entityDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type subgraphIdDirectiveArgs = {
+  id: Scalars['String'];
+};
+
+export type subgraphIdDirectiveResolver<Result, Parent, ContextType = MeshContext & { url: string }, Args = subgraphIdDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type derivedFromDirectiveArgs = {
+  field: Scalars['String'];
+};
+
+export type derivedFromDirectiveResolver<Result, Parent, ContextType = MeshContext & { url: string }, Args = derivedFromDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export interface BigDecimalScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['BigDecimal'], any> {
+  name: 'BigDecimal';
+}
+
+export interface BigIntScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['BigInt'], any> {
+  name: 'BigInt';
+}
+
+export type BookResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['Book'] = ResolversParentTypes['Book']> = ResolversObject<{
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  base?: Resolver<ResolversTypes['Token'], ParentType, ContextType>;
+  quote?: Resolver<ResolversTypes['Token'], ParentType, ContextType>;
+  unit?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  makerPolicy?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  takerPolicy?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  hooks?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  depths?: Resolver<Array<ResolversTypes['Depth']>, ParentType, ContextType, RequireFields<BookdepthsArgs, 'skip' | 'first'>>;
+  openOrders?: Resolver<Array<ResolversTypes['OpenOrder']>, ParentType, ContextType, RequireFields<BookopenOrdersArgs, 'skip' | 'first'>>;
+  latestTick?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  latestPrice?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  latestTimestamp?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export interface BytesScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Bytes'], any> {
+  name: 'Bytes';
+}
+
+export type ChartLogResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['ChartLog'] = ResolversParentTypes['ChartLog']> = ResolversObject<{
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  marketCode?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  intervalType?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  timestamp?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  open?: Resolver<ResolversTypes['BigDecimal'], ParentType, ContextType>;
+  high?: Resolver<ResolversTypes['BigDecimal'], ParentType, ContextType>;
+  low?: Resolver<ResolversTypes['BigDecimal'], ParentType, ContextType>;
+  close?: Resolver<ResolversTypes['BigDecimal'], ParentType, ContextType>;
+  baseVolume?: Resolver<ResolversTypes['BigDecimal'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type DepthResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['Depth'] = ResolversParentTypes['Depth']> = ResolversObject<{
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  book?: Resolver<ResolversTypes['Book'], ParentType, ContextType>;
+  tick?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  price?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  latestTakenOrderIndex?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export interface Int8ScalarConfig extends GraphQLScalarTypeConfig<ResolversTypes['Int8'], any> {
+  name: 'Int8';
+}
+
+export type OpenOrderResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['OpenOrder'] = ResolversParentTypes['OpenOrder']> = ResolversObject<{
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  book?: Resolver<ResolversTypes['Book'], ParentType, ContextType>;
+  tick?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  orderIndex?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  price?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  user?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  txHash?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  createdAt?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawFilledAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseFilledAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteFilledAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawClaimedAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseClaimedAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteClaimedAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawClaimableAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseClaimableAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteClaimableAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  rawOpenAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  baseOpenAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  quoteOpenAmount?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type QueryResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['Query'] = ResolversParentTypes['Query']> = ResolversObject<{
+  token?: Resolver<Maybe<ResolversTypes['Token']>, ParentType, ContextType, RequireFields<QuerytokenArgs, 'id' | 'subgraphError'>>;
+  tokens?: Resolver<Array<ResolversTypes['Token']>, ParentType, ContextType, RequireFields<QuerytokensArgs, 'skip' | 'first' | 'subgraphError'>>;
+  book?: Resolver<Maybe<ResolversTypes['Book']>, ParentType, ContextType, RequireFields<QuerybookArgs, 'id' | 'subgraphError'>>;
+  books?: Resolver<Array<ResolversTypes['Book']>, ParentType, ContextType, RequireFields<QuerybooksArgs, 'skip' | 'first' | 'subgraphError'>>;
+  depth?: Resolver<Maybe<ResolversTypes['Depth']>, ParentType, ContextType, RequireFields<QuerydepthArgs, 'id' | 'subgraphError'>>;
+  depths?: Resolver<Array<ResolversTypes['Depth']>, ParentType, ContextType, RequireFields<QuerydepthsArgs, 'skip' | 'first' | 'subgraphError'>>;
+  openOrder?: Resolver<Maybe<ResolversTypes['OpenOrder']>, ParentType, ContextType, RequireFields<QueryopenOrderArgs, 'id' | 'subgraphError'>>;
+  openOrders?: Resolver<Array<ResolversTypes['OpenOrder']>, ParentType, ContextType, RequireFields<QueryopenOrdersArgs, 'skip' | 'first' | 'subgraphError'>>;
+  chartLog?: Resolver<Maybe<ResolversTypes['ChartLog']>, ParentType, ContextType, RequireFields<QuerychartLogArgs, 'id' | 'subgraphError'>>;
+  chartLogs?: Resolver<Array<ResolversTypes['ChartLog']>, ParentType, ContextType, RequireFields<QuerychartLogsArgs, 'skip' | 'first' | 'subgraphError'>>;
+  _meta?: Resolver<Maybe<ResolversTypes['_Meta_']>, ParentType, ContextType, Partial<Query_metaArgs>>;
+}>;
+
+export type SubscriptionResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['Subscription'] = ResolversParentTypes['Subscription']> = ResolversObject<{
+  token?: SubscriptionResolver<Maybe<ResolversTypes['Token']>, "token", ParentType, ContextType, RequireFields<SubscriptiontokenArgs, 'id' | 'subgraphError'>>;
+  tokens?: SubscriptionResolver<Array<ResolversTypes['Token']>, "tokens", ParentType, ContextType, RequireFields<SubscriptiontokensArgs, 'skip' | 'first' | 'subgraphError'>>;
+  book?: SubscriptionResolver<Maybe<ResolversTypes['Book']>, "book", ParentType, ContextType, RequireFields<SubscriptionbookArgs, 'id' | 'subgraphError'>>;
+  books?: SubscriptionResolver<Array<ResolversTypes['Book']>, "books", ParentType, ContextType, RequireFields<SubscriptionbooksArgs, 'skip' | 'first' | 'subgraphError'>>;
+  depth?: SubscriptionResolver<Maybe<ResolversTypes['Depth']>, "depth", ParentType, ContextType, RequireFields<SubscriptiondepthArgs, 'id' | 'subgraphError'>>;
+  depths?: SubscriptionResolver<Array<ResolversTypes['Depth']>, "depths", ParentType, ContextType, RequireFields<SubscriptiondepthsArgs, 'skip' | 'first' | 'subgraphError'>>;
+  openOrder?: SubscriptionResolver<Maybe<ResolversTypes['OpenOrder']>, "openOrder", ParentType, ContextType, RequireFields<SubscriptionopenOrderArgs, 'id' | 'subgraphError'>>;
+  openOrders?: SubscriptionResolver<Array<ResolversTypes['OpenOrder']>, "openOrders", ParentType, ContextType, RequireFields<SubscriptionopenOrdersArgs, 'skip' | 'first' | 'subgraphError'>>;
+  chartLog?: SubscriptionResolver<Maybe<ResolversTypes['ChartLog']>, "chartLog", ParentType, ContextType, RequireFields<SubscriptionchartLogArgs, 'id' | 'subgraphError'>>;
+  chartLogs?: SubscriptionResolver<Array<ResolversTypes['ChartLog']>, "chartLogs", ParentType, ContextType, RequireFields<SubscriptionchartLogsArgs, 'skip' | 'first' | 'subgraphError'>>;
+  _meta?: SubscriptionResolver<Maybe<ResolversTypes['_Meta_']>, "_meta", ParentType, ContextType, Partial<Subscription_metaArgs>>;
+}>;
+
+export type TokenResolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['Token'] = ResolversParentTypes['Token']> = ResolversObject<{
+  id?: Resolver<ResolversTypes['ID'], ParentType, ContextType>;
+  symbol?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  decimals?: Resolver<ResolversTypes['BigInt'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type _Block_Resolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['_Block_'] = ResolversParentTypes['_Block_']> = ResolversObject<{
+  hash?: Resolver<Maybe<ResolversTypes['Bytes']>, ParentType, ContextType>;
+  number?: Resolver<ResolversTypes['Int'], ParentType, ContextType>;
+  timestamp?: Resolver<Maybe<ResolversTypes['Int']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type _Meta_Resolvers<ContextType = MeshContext & { url: string }, ParentType extends ResolversParentTypes['_Meta_'] = ResolversParentTypes['_Meta_']> = ResolversObject<{
+  block?: Resolver<ResolversTypes['_Block_'], ParentType, ContextType>;
+  deployment?: Resolver<ResolversTypes['String'], ParentType, ContextType>;
+  hasIndexingErrors?: Resolver<ResolversTypes['Boolean'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+}>;
+
+export type Resolvers<ContextType = MeshContext & { url: string }> = ResolversObject<{
+  BigDecimal?: GraphQLScalarType;
+  BigInt?: GraphQLScalarType;
+  Book?: BookResolvers<ContextType>;
+  Bytes?: GraphQLScalarType;
+  ChartLog?: ChartLogResolvers<ContextType>;
+  Depth?: DepthResolvers<ContextType>;
+  Int8?: GraphQLScalarType;
+  OpenOrder?: OpenOrderResolvers<ContextType>;
+  Query?: QueryResolvers<ContextType>;
+  Subscription?: SubscriptionResolvers<ContextType>;
+  Token?: TokenResolvers<ContextType>;
+  _Block_?: _Block_Resolvers<ContextType>;
+  _Meta_?: _Meta_Resolvers<ContextType>;
+}>;
+
+export type DirectiveResolvers<ContextType = MeshContext & { url: string }> = ResolversObject<{
+  entity?: entityDirectiveResolver<any, any, ContextType>;
+  subgraphId?: subgraphIdDirectiveResolver<any, any, ContextType>;
+  derivedFrom?: derivedFromDirectiveResolver<any, any, ContextType>;
+}>;
+
+export type MeshContext = CloberV2Types.Context & BaseMeshContext;
+
+
+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 ".graphclient/sources/clober-v2/introspectionSchema":
+      return Promise.resolve(importedModule$0) as T;
+    
+    default:
+      return Promise.reject(new Error(`Cannot find module '${relativeModuleId}'.`));
+  }
+};
+
+const rootStore = new MeshStore('.graphclient', new FsStoreStorageAdapter({
+  cwd: baseDir,
+  importFn,
+  fileType: "ts",
+}), {
+  readonly: true,
+  validate: false
+});
+
+export const rawServeConfig: YamlConfig.Config['serve'] = undefined as any
+export async function getMeshOptions(): Promise<GetMeshOptions> {
+const pubsub = new PubSub();
+const sourcesStore = rootStore.child('sources');
+const logger = new DefaultLogger("GraphClient");
+const cache = new (MeshCache as any)({
+      ...({} as any),
+      importFn,
+      store: rootStore.child('cache'),
+      pubsub,
+      logger,
+    } as any)
+
+const sources: MeshResolvedSource[] = [];
+const transforms: MeshTransform[] = [];
+const additionalEnvelopPlugins: MeshPlugin<any>[] = [];
+const cloberV2Transforms = [];
+const additionalTypeDefs = [] as any[];
+const cloberV2Handler = new GraphqlHandler({
+              name: "clober-v2",
+              config: {"endpoint":"{context.url:https://subgraph.satsuma-prod.com/f6a8c4889b7b/clober/v2-core-subgraph/api}"},
+              baseDir,
+              cache,
+              pubsub,
+              store: sourcesStore.child("clober-v2"),
+              logger: logger.child("clober-v2"),
+              importFn,
+            });
+sources[0] = {
+          name: 'clober-v2',
+          handler: cloberV2Handler,
+          transforms: cloberV2Transforms
+        }
+const additionalResolvers = [] as any[]
+const merger = new(BareMerger as any)({
+        cache,
+        pubsub,
+        logger: logger.child('bareMerger'),
+        store: rootStore.child('bareMerger')
+      })
+
+  return {
+    sources,
+    transforms,
+    additionalTypeDefs,
+    additionalResolvers,
+    cache,
+    pubsub,
+    merger,
+    logger,
+    additionalEnvelopPlugins,
+    get documents() {
+      return [
+      {
+        document: GetBooksDocument,
+        get rawSDL() {
+          return printWithCache(GetBooksDocument);
+        },
+        location: 'GetBooksDocument.graphql'
+      },{
+        document: GetOpenOrderDocument,
+        get rawSDL() {
+          return printWithCache(GetOpenOrderDocument);
+        },
+        location: 'GetOpenOrderDocument.graphql'
+      },{
+        document: GetOpenOrdersDocument,
+        get rawSDL() {
+          return printWithCache(GetOpenOrdersDocument);
+        },
+        location: 'GetOpenOrdersDocument.graphql'
+      }
+    ];
+    },
+    fetchFn,
+  };
+}
+
+export function createBuiltMeshHTTPHandler<TServerContext = {}>(): MeshHTTPHandler<TServerContext> {
+  return createMeshHTTPHandler<TServerContext>({
+    baseDir,
+    getBuiltMesh: getBuiltGraphClient,
+    rawServeConfig: undefined,
+  })
+}
+
+
+let meshInstance$: Promise<MeshInstance> | undefined;
+
+export function getBuiltGraphClient(): Promise<MeshInstance> {
+  if (meshInstance$ == null) {
+    meshInstance$ = getMeshOptions().then(meshOptions => getMesh(meshOptions)).then(mesh => {
+      const id = mesh.pubsub.subscribe('destroy', () => {
+        meshInstance$ = undefined;
+        mesh.pubsub.unsubscribe(id);
+      });
+      return mesh;
+    });
+  }
+  return meshInstance$;
+}
+
+export const execute: ExecuteMeshFn = (...args) => getBuiltGraphClient().then(({ execute }) => execute(...args));
+
+export const subscribe: SubscribeMeshFn = (...args) => getBuiltGraphClient().then(({ subscribe }) => subscribe(...args));
+export function getBuiltGraphSDK<TGlobalContext = any, TOperationContext = any>(globalContext?: TGlobalContext) {
+  const sdkRequester$ = getBuiltGraphClient().then(({ sdkRequesterFactory }) => sdkRequesterFactory(globalContext));
+  return getSdk<TOperationContext, TGlobalContext>((...args) => sdkRequester$.then(sdkRequester => sdkRequester(...args)));
+}
+export type getBooksQueryVariables = Exact<{
+  baseTokenAddress: Scalars['String'];
+  quoteTokenAddress: Scalars['String'];
+}>;
+
+
+export type getBooksQuery = { books: Array<(
+    Pick<Book, 'id' | 'unit'>
+    & { base: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'>, quote: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'>, depths: Array<Pick<Depth, 'tick' | 'price' | 'rawAmount'>> }
+  )> };
+
+export type getOpenOrderQueryVariables = Exact<{
+  orderId: Scalars['ID'];
+}>;
+
+
+export type getOpenOrderQuery = { openOrder?: Maybe<(
+    Pick<OpenOrder, 'id' | 'tick' | 'txHash' | 'createdAt' | 'rawAmount' | 'rawFilledAmount' | 'rawClaimedAmount' | 'rawClaimableAmount'>
+    & { book: (
+      Pick<Book, 'id' | 'unit'>
+      & { base: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'>, quote: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'> }
+    ) }
+  )> };
+
+export type getOpenOrdersQueryVariables = Exact<{
+  userAddress: Scalars['String'];
+}>;
+
+
+export type getOpenOrdersQuery = { openOrders: Array<(
+    Pick<OpenOrder, 'id' | 'tick' | 'txHash' | 'createdAt' | 'rawAmount' | 'rawFilledAmount' | 'rawClaimedAmount' | 'rawClaimableAmount'>
+    & { book: (
+      Pick<Book, 'id' | 'unit'>
+      & { base: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'>, quote: Pick<Token, 'id' | 'name' | 'symbol' | 'decimals'> }
+    ) }
+  )> };
+
+
+export const getBooksDocument = gql`
+    query getBooks($baseTokenAddress: String!, $quoteTokenAddress: String!) {
+  books(
+    where: {base: $baseTokenAddress, quote: $quoteTokenAddress, makerPolicy: "8888308", takerPolicy: "8889608", hooks: "0x0000000000000000000000000000000000000000"}
+  ) {
+    id
+    base {
+      id
+      name
+      symbol
+      decimals
+    }
+    quote {
+      id
+      name
+      symbol
+      decimals
+    }
+    unit
+    depths {
+      tick
+      price
+      rawAmount
+    }
+  }
+}
+    ` as unknown as DocumentNode<getBooksQuery, getBooksQueryVariables>;
+export const getOpenOrderDocument = gql`
+    query getOpenOrder($orderId: ID!) {
+  openOrder(id: $orderId) {
+    id
+    book {
+      id
+      base {
+        id
+        name
+        symbol
+        decimals
+      }
+      quote {
+        id
+        name
+        symbol
+        decimals
+      }
+      unit
+    }
+    tick
+    txHash
+    createdAt
+    rawAmount
+    rawFilledAmount
+    rawClaimedAmount
+    rawClaimableAmount
+  }
+}
+    ` as unknown as DocumentNode<getOpenOrderQuery, getOpenOrderQueryVariables>;
+export const getOpenOrdersDocument = gql`
+    query getOpenOrders($userAddress: String!) {
+  openOrders(where: {user: $userAddress}) {
+    id
+    book {
+      id
+      base {
+        id
+        name
+        symbol
+        decimals
+      }
+      quote {
+        id
+        name
+        symbol
+        decimals
+      }
+      unit
+    }
+    tick
+    txHash
+    createdAt
+    rawAmount
+    rawFilledAmount
+    rawClaimedAmount
+    rawClaimableAmount
+  }
+}
+    ` as unknown as DocumentNode<getOpenOrdersQuery, getOpenOrdersQueryVariables>;
+
+
+
+
+export type Requester<C = {}, E = unknown> = <R, V>(doc: DocumentNode, vars?: V, options?: C) => Promise<R> | AsyncIterable<R>
+export function getSdk<C, E>(requester: Requester<C, E>) {
+  return {
+    getBooks(variables: getBooksQueryVariables, options?: C): Promise<getBooksQuery> {
+      return requester<getBooksQuery, getBooksQueryVariables>(getBooksDocument, variables, options) as Promise<getBooksQuery>;
+    },
+    getOpenOrder(variables: getOpenOrderQueryVariables, options?: C): Promise<getOpenOrderQuery> {
+      return requester<getOpenOrderQuery, getOpenOrderQueryVariables>(getOpenOrderDocument, variables, options) as Promise<getOpenOrderQuery>;
+    },
+    getOpenOrders(variables: getOpenOrdersQueryVariables, options?: C): Promise<getOpenOrdersQuery> {
+      return requester<getOpenOrdersQuery, getOpenOrdersQueryVariables>(getOpenOrdersDocument, variables, options) as Promise<getOpenOrdersQuery>;
+    }
+  };
+}
+export type Sdk = ReturnType<typeof getSdk>;