diff --git a/.gitignore b/.gitignore
index b94ddd180d8..e490bd1192e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -8,7 +8,7 @@
 /src/locales/**/*.po
 
 # generated files
-/src/**/__generated__
+# /src/**/__generated__
 
 # schema
 schema.graphql
diff --git a/src/graphql/data/__generated__/types-and-hooks.ts b/src/graphql/data/__generated__/types-and-hooks.ts
new file mode 100644
index 00000000000..41ff1d19d0b
--- /dev/null
+++ b/src/graphql/data/__generated__/types-and-hooks.ts
@@ -0,0 +1,3080 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T;
+export type InputMaybe<T> = 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]> };
+const defaultOptions = {} as const;
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  /**
+   * The `AWSJSON` scalar type provided by AWS AppSync, represents a JSON string that
+   * complies with [RFC 8259](https://tools.ietf.org/html/rfc8259).  Maps like
+   * "**{\\"upvotes\\": 10}**", lists like "**[1,2,3]**", and scalar values like
+   * "**\\"AWSJSON example string\\"**", "**1**", and "**true**" are accepted as
+   * valid JSON and will automatically be parsed and loaded in the resolver mapping
+   * templates as Maps, Lists, or Scalar values rather than as the literal input
+   * strings.  Invalid JSON strings like "**{a: 1}**", "**{'a': 1}**" and "**Unquoted
+   * string**" will throw GraphQL validation errors.
+   */
+  AWSJSON: any;
+};
+
+export type ActivityDetails = SwapOrderDetails | TransactionDetails;
+
+/**   deprecated and replaced with TransactionType, please do not use this */
+export enum ActivityType {
+  Approve = 'APPROVE',
+  Borrow = 'BORROW',
+  Burn = 'BURN',
+  Cancel = 'CANCEL',
+  Claim = 'CLAIM',
+  Deployment = 'DEPLOYMENT',
+  Lend = 'LEND',
+  Mint = 'MINT',
+  Nft = 'NFT',
+  Receive = 'RECEIVE',
+  Repay = 'REPAY',
+  Send = 'SEND',
+  Stake = 'STAKE',
+  Swap = 'SWAP',
+  SwapOrder = 'SWAP_ORDER',
+  Staking = 'Staking',
+  Unknown = 'UNKNOWN',
+  Unstake = 'UNSTAKE',
+  Withdraw = 'WITHDRAW',
+  Market = 'market',
+  Money = 'money'
+}
+
+export type Amount = IAmount & {
+  readonly __typename?: 'Amount';
+  readonly currency?: Maybe<Currency>;
+  readonly id: Scalars['ID'];
+  readonly value: Scalars['Float'];
+};
+
+export type AmountChange = {
+  readonly __typename?: 'AmountChange';
+  readonly absolute?: Maybe<Amount>;
+  readonly id: Scalars['ID'];
+  readonly percentage?: Maybe<Amount>;
+};
+
+export type AmountInput = {
+  readonly currency: Currency;
+  readonly value: Scalars['Float'];
+};
+
+export type AssetActivity = {
+  readonly __typename?: 'AssetActivity';
+  /** @deprecated use assetChanges field in details */
+  readonly assetChanges: ReadonlyArray<Maybe<AssetChange>>;
+  readonly chain: Chain;
+  readonly details: ActivityDetails;
+  /** @deprecated not required, remove usage */
+  readonly gasUsed?: Maybe<Scalars['Float']>;
+  readonly id: Scalars['ID'];
+  readonly timestamp: Scalars['Int'];
+  /** @deprecated use fields from details */
+  readonly transaction: Transaction;
+  /** @deprecated use type field in details */
+  readonly type: ActivityType;
+};
+
+export type AssetChange = NftApproval | NftApproveForAll | NftTransfer | TokenApproval | TokenTransfer;
+
+export enum Chain {
+  Arbitrum = 'ARBITRUM',
+  Avalanche = 'AVALANCHE',
+  Base = 'BASE',
+  Bnb = 'BNB',
+  Celo = 'CELO',
+  Ethereum = 'ETHEREUM',
+  EthereumGoerli = 'ETHEREUM_GOERLI',
+  EthereumSepolia = 'ETHEREUM_SEPOLIA',
+  Optimism = 'OPTIMISM',
+  Polygon = 'POLYGON',
+  UnknownChain = 'UNKNOWN_CHAIN'
+}
+
+export enum CollectionSortableField {
+  Volume = 'VOLUME'
+}
+
+export type ContractInput = {
+  readonly address?: InputMaybe<Scalars['String']>;
+  readonly chain: Chain;
+};
+
+export enum Currency {
+  Aud = 'AUD',
+  Brl = 'BRL',
+  Cad = 'CAD',
+  Eth = 'ETH',
+  Eur = 'EUR',
+  Gbp = 'GBP',
+  Hkd = 'HKD',
+  Idr = 'IDR',
+  Inr = 'INR',
+  Jpy = 'JPY',
+  Matic = 'MATIC',
+  Ngn = 'NGN',
+  Pkr = 'PKR',
+  Rub = 'RUB',
+  Sgd = 'SGD',
+  Thb = 'THB',
+  Try = 'TRY',
+  Uah = 'UAH',
+  Usd = 'USD',
+  Vnd = 'VND'
+}
+
+export type Dimensions = {
+  readonly __typename?: 'Dimensions';
+  readonly height?: Maybe<Scalars['Float']>;
+  readonly id: Scalars['ID'];
+  readonly width?: Maybe<Scalars['Float']>;
+};
+
+export enum HighLow {
+  High = 'HIGH',
+  Low = 'LOW'
+}
+
+export enum HistoryDuration {
+  Day = 'DAY',
+  Hour = 'HOUR',
+  Max = 'MAX',
+  Month = 'MONTH',
+  Week = 'WEEK',
+  Year = 'YEAR'
+}
+
+export type IAmount = {
+  readonly currency?: Maybe<Currency>;
+  readonly value: Scalars['Float'];
+};
+
+export type IContract = {
+  readonly address?: Maybe<Scalars['String']>;
+  readonly chain: Chain;
+};
+
+export type Image = {
+  readonly __typename?: 'Image';
+  readonly dimensions?: Maybe<Dimensions>;
+  readonly id: Scalars['ID'];
+  readonly url: Scalars['String'];
+};
+
+export enum MediaType {
+  Audio = 'AUDIO',
+  Image = 'IMAGE',
+  Raw = 'RAW',
+  Video = 'VIDEO'
+}
+
+export type NftActivity = {
+  readonly __typename?: 'NftActivity';
+  readonly address: Scalars['String'];
+  readonly asset?: Maybe<NftAsset>;
+  readonly fromAddress: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly marketplace?: Maybe<Scalars['String']>;
+  readonly orderStatus?: Maybe<OrderStatus>;
+  readonly price?: Maybe<Amount>;
+  readonly quantity?: Maybe<Scalars['Int']>;
+  readonly timestamp: Scalars['Int'];
+  readonly toAddress?: Maybe<Scalars['String']>;
+  readonly tokenId?: Maybe<Scalars['String']>;
+  readonly transactionHash?: Maybe<Scalars['String']>;
+  readonly type: NftActivityType;
+  readonly url?: Maybe<Scalars['String']>;
+};
+
+export type NftActivityConnection = {
+  readonly __typename?: 'NftActivityConnection';
+  readonly edges: ReadonlyArray<NftActivityEdge>;
+  readonly pageInfo: PageInfo;
+};
+
+export type NftActivityEdge = {
+  readonly __typename?: 'NftActivityEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftActivity;
+};
+
+export type NftActivityFilterInput = {
+  readonly activityTypes?: InputMaybe<ReadonlyArray<NftActivityType>>;
+  readonly address?: InputMaybe<Scalars['String']>;
+  readonly tokenId?: InputMaybe<Scalars['String']>;
+};
+
+export enum NftActivityType {
+  CancelListing = 'CANCEL_LISTING',
+  Listing = 'LISTING',
+  Sale = 'SALE',
+  Transfer = 'TRANSFER'
+}
+
+export type NftApproval = {
+  readonly __typename?: 'NftApproval';
+  readonly approvedAddress: Scalars['String'];
+  /**   can be erc721, erc1155, noncompliant */
+  readonly asset: NftAsset;
+  readonly id: Scalars['ID'];
+  readonly nftStandard: NftStandard;
+};
+
+export type NftApproveForAll = {
+  readonly __typename?: 'NftApproveForAll';
+  readonly approved: Scalars['Boolean'];
+  /**   can be erc721, erc1155, noncompliant */
+  readonly asset: NftAsset;
+  readonly id: Scalars['ID'];
+  readonly nftStandard: NftStandard;
+  readonly operatorAddress: Scalars['String'];
+};
+
+export type NftAsset = {
+  readonly __typename?: 'NftAsset';
+  readonly animationUrl?: Maybe<Scalars['String']>;
+  readonly collection?: Maybe<NftCollection>;
+  readonly creator?: Maybe<NftProfile>;
+  readonly description?: Maybe<Scalars['String']>;
+  readonly flaggedBy?: Maybe<Scalars['String']>;
+  readonly id: Scalars['ID'];
+  readonly image?: Maybe<Image>;
+  /** @deprecated Field no longer supported */
+  readonly imageUrl?: Maybe<Scalars['String']>;
+  readonly isSpam?: Maybe<Scalars['Boolean']>;
+  readonly listings?: Maybe<NftOrderConnection>;
+  readonly mediaType?: Maybe<MediaType>;
+  readonly metadataUrl?: Maybe<Scalars['String']>;
+  readonly name?: Maybe<Scalars['String']>;
+  readonly nftContract?: Maybe<NftContract>;
+  readonly originalImage?: Maybe<Image>;
+  /**   TODO: may need to be array to support erc1155 cases. not needed at the moment so will revisit. */
+  readonly ownerAddress?: Maybe<Scalars['String']>;
+  readonly rarities?: Maybe<ReadonlyArray<NftAssetRarity>>;
+  readonly smallImage?: Maybe<Image>;
+  /** @deprecated Field no longer supported */
+  readonly smallImageUrl?: Maybe<Scalars['String']>;
+  readonly suspiciousFlag?: Maybe<Scalars['Boolean']>;
+  readonly thumbnail?: Maybe<Image>;
+  /** @deprecated Field no longer supported */
+  readonly thumbnailUrl?: Maybe<Scalars['String']>;
+  readonly tokenId: Scalars['String'];
+  readonly traits?: Maybe<ReadonlyArray<NftAssetTrait>>;
+};
+
+
+export type NftAssetListingsArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  asc?: InputMaybe<Scalars['Boolean']>;
+  before?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  first?: InputMaybe<Scalars['Int']>;
+  last?: InputMaybe<Scalars['Int']>;
+};
+
+export type NftAssetConnection = {
+  readonly __typename?: 'NftAssetConnection';
+  readonly edges: ReadonlyArray<NftAssetEdge>;
+  readonly pageInfo: PageInfo;
+  readonly totalCount?: Maybe<Scalars['Int']>;
+};
+
+export type NftAssetEdge = {
+  readonly __typename?: 'NftAssetEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftAsset;
+};
+
+export type NftAssetInput = {
+  readonly address: Scalars['String'];
+  readonly tokenId: Scalars['String'];
+};
+
+export type NftAssetRarity = {
+  readonly __typename?: 'NftAssetRarity';
+  readonly id: Scalars['ID'];
+  readonly provider?: Maybe<NftRarityProvider>;
+  readonly rank?: Maybe<Scalars['Int']>;
+  readonly score?: Maybe<Scalars['Float']>;
+};
+
+export enum NftAssetSortableField {
+  Price = 'PRICE',
+  Rarity = 'RARITY'
+}
+
+export type NftAssetTrait = {
+  readonly __typename?: 'NftAssetTrait';
+  readonly id: Scalars['ID'];
+  readonly name?: Maybe<Scalars['String']>;
+  readonly rarity?: Maybe<Scalars['Float']>;
+  readonly value?: Maybe<Scalars['String']>;
+};
+
+export type NftAssetTraitInput = {
+  readonly name: Scalars['String'];
+  readonly values: ReadonlyArray<Scalars['String']>;
+};
+
+export type NftAssetsFilterInput = {
+  readonly listed?: InputMaybe<Scalars['Boolean']>;
+  readonly marketplaces?: InputMaybe<ReadonlyArray<NftMarketplace>>;
+  readonly maxPrice?: InputMaybe<Scalars['String']>;
+  readonly minPrice?: InputMaybe<Scalars['String']>;
+  readonly tokenIds?: InputMaybe<ReadonlyArray<Scalars['String']>>;
+  readonly tokenSearchQuery?: InputMaybe<Scalars['String']>;
+  readonly traits?: InputMaybe<ReadonlyArray<NftAssetTraitInput>>;
+};
+
+export type NftBalance = {
+  readonly __typename?: 'NftBalance';
+  readonly id: Scalars['ID'];
+  readonly lastPrice?: Maybe<TimestampedAmount>;
+  readonly listedMarketplaces?: Maybe<ReadonlyArray<NftMarketplace>>;
+  readonly listingFees?: Maybe<ReadonlyArray<Maybe<NftFee>>>;
+  readonly ownedAsset?: Maybe<NftAsset>;
+  readonly quantity?: Maybe<Scalars['Int']>;
+};
+
+export type NftBalanceConnection = {
+  readonly __typename?: 'NftBalanceConnection';
+  readonly edges: ReadonlyArray<NftBalanceEdge>;
+  readonly pageInfo: PageInfo;
+};
+
+export type NftBalanceEdge = {
+  readonly __typename?: 'NftBalanceEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftBalance;
+};
+
+export type NftBalancesFilterInput = {
+  readonly addresses?: InputMaybe<ReadonlyArray<Scalars['String']>>;
+  readonly assets?: InputMaybe<ReadonlyArray<NftAssetInput>>;
+  readonly filterSpam?: InputMaybe<Scalars['Boolean']>;
+};
+
+export type NftCollection = {
+  readonly __typename?: 'NftCollection';
+  readonly bannerImage?: Maybe<Image>;
+  /**
+   *  TODO: support querying for collection assets here
+   * assets(page: Int, pageSize: Int, orderBy: NftAssetSortableField): [NftAsset]
+   * @deprecated Field no longer supported
+   */
+  readonly bannerImageUrl?: Maybe<Scalars['String']>;
+  readonly collectionId: Scalars['String'];
+  readonly creator?: Maybe<NftProfile>;
+  readonly description?: Maybe<Scalars['String']>;
+  readonly discordUrl?: Maybe<Scalars['String']>;
+  readonly homepageUrl?: Maybe<Scalars['String']>;
+  readonly id: Scalars['ID'];
+  readonly image?: Maybe<Image>;
+  /** @deprecated Field no longer supported */
+  readonly imageUrl?: Maybe<Scalars['String']>;
+  readonly instagramName?: Maybe<Scalars['String']>;
+  readonly isVerified?: Maybe<Scalars['Boolean']>;
+  readonly markets?: Maybe<ReadonlyArray<NftCollectionMarket>>;
+  readonly name?: Maybe<Scalars['String']>;
+  readonly nftContracts?: Maybe<ReadonlyArray<NftContract>>;
+  readonly numAssets?: Maybe<Scalars['Int']>;
+  /** @deprecated Field no longer supported */
+  readonly openseaUrl?: Maybe<Scalars['String']>;
+  readonly traits?: Maybe<ReadonlyArray<NftCollectionTrait>>;
+  readonly twitterName?: Maybe<Scalars['String']>;
+};
+
+
+export type NftCollectionMarketsArgs = {
+  currencies: ReadonlyArray<Currency>;
+};
+
+export type NftCollectionBalance = {
+  readonly __typename?: 'NftCollectionBalance';
+  readonly address: Scalars['String'];
+  readonly balance: Scalars['Float'];
+  readonly id: Scalars['ID'];
+  readonly logoImage?: Maybe<Image>;
+  readonly name: Scalars['String'];
+};
+
+export type NftCollectionBalanceConnection = {
+  readonly __typename?: 'NftCollectionBalanceConnection';
+  readonly edges: ReadonlyArray<NftCollectionBalanceEdge>;
+  readonly pageInfo: PageInfo;
+};
+
+export type NftCollectionBalanceEdge = {
+  readonly __typename?: 'NftCollectionBalanceEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftCollectionBalance;
+};
+
+export type NftCollectionConnection = {
+  readonly __typename?: 'NftCollectionConnection';
+  readonly edges: ReadonlyArray<NftCollectionEdge>;
+  readonly pageInfo: PageInfo;
+};
+
+export type NftCollectionEdge = {
+  readonly __typename?: 'NftCollectionEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftCollection;
+};
+
+export type NftCollectionMarket = {
+  readonly __typename?: 'NftCollectionMarket';
+  readonly floorPrice?: Maybe<TimestampedAmount>;
+  readonly floorPricePercentChange?: Maybe<TimestampedAmount>;
+  readonly id: Scalars['ID'];
+  readonly listings?: Maybe<TimestampedAmount>;
+  readonly marketplaces?: Maybe<ReadonlyArray<NftCollectionMarketplace>>;
+  readonly nftContracts?: Maybe<ReadonlyArray<NftContract>>;
+  readonly owners?: Maybe<Scalars['Int']>;
+  readonly percentListed?: Maybe<TimestampedAmount>;
+  readonly percentUniqueOwners?: Maybe<TimestampedAmount>;
+  readonly sales?: Maybe<TimestampedAmount>;
+  readonly totalVolume?: Maybe<TimestampedAmount>;
+  readonly volume?: Maybe<TimestampedAmount>;
+  /** @deprecated Field no longer supported */
+  readonly volume24h?: Maybe<Amount>;
+  readonly volumePercentChange?: Maybe<TimestampedAmount>;
+};
+
+
+export type NftCollectionMarketFloorPricePercentChangeArgs = {
+  duration?: InputMaybe<HistoryDuration>;
+};
+
+
+export type NftCollectionMarketMarketplacesArgs = {
+  marketplaces?: InputMaybe<ReadonlyArray<NftMarketplace>>;
+};
+
+
+export type NftCollectionMarketSalesArgs = {
+  duration?: InputMaybe<HistoryDuration>;
+};
+
+
+export type NftCollectionMarketVolumeArgs = {
+  duration?: InputMaybe<HistoryDuration>;
+};
+
+
+export type NftCollectionMarketVolumePercentChangeArgs = {
+  duration?: InputMaybe<HistoryDuration>;
+};
+
+export type NftCollectionMarketplace = {
+  readonly __typename?: 'NftCollectionMarketplace';
+  readonly floorPrice?: Maybe<Scalars['Float']>;
+  readonly id: Scalars['ID'];
+  readonly listings?: Maybe<Scalars['Int']>;
+  readonly marketplace?: Maybe<NftMarketplace>;
+};
+
+export type NftCollectionTrait = {
+  readonly __typename?: 'NftCollectionTrait';
+  readonly id: Scalars['ID'];
+  readonly name?: Maybe<Scalars['String']>;
+  readonly stats?: Maybe<ReadonlyArray<NftCollectionTraitStats>>;
+  readonly values?: Maybe<ReadonlyArray<Scalars['String']>>;
+};
+
+export type NftCollectionTraitStats = {
+  readonly __typename?: 'NftCollectionTraitStats';
+  readonly assets?: Maybe<Scalars['Int']>;
+  readonly id: Scalars['ID'];
+  readonly listings?: Maybe<Scalars['Int']>;
+  readonly name?: Maybe<Scalars['String']>;
+  readonly value?: Maybe<Scalars['String']>;
+};
+
+export type NftCollectionsFilterInput = {
+  readonly addresses?: InputMaybe<ReadonlyArray<Scalars['String']>>;
+  readonly nameQuery?: InputMaybe<Scalars['String']>;
+};
+
+export type NftContract = IContract & {
+  readonly __typename?: 'NftContract';
+  readonly address: Scalars['String'];
+  readonly chain: Chain;
+  readonly id: Scalars['ID'];
+  readonly name?: Maybe<Scalars['String']>;
+  readonly standard?: Maybe<NftStandard>;
+  readonly symbol?: Maybe<Scalars['String']>;
+  readonly totalSupply?: Maybe<Scalars['Int']>;
+};
+
+export type NftFee = {
+  readonly __typename?: 'NftFee';
+  readonly basisPoints: Scalars['Int'];
+  readonly id: Scalars['ID'];
+  readonly payoutAddress: Scalars['String'];
+};
+
+export enum NftMarketplace {
+  Cryptopunks = 'CRYPTOPUNKS',
+  Foundation = 'FOUNDATION',
+  Looksrare = 'LOOKSRARE',
+  Nft20 = 'NFT20',
+  Nftx = 'NFTX',
+  Opensea = 'OPENSEA',
+  Sudoswap = 'SUDOSWAP',
+  X2Y2 = 'X2Y2'
+}
+
+export type NftOrder = {
+  readonly __typename?: 'NftOrder';
+  readonly address: Scalars['String'];
+  readonly auctionType?: Maybe<Scalars['String']>;
+  readonly createdAt: Scalars['Float'];
+  readonly endAt?: Maybe<Scalars['Float']>;
+  readonly id: Scalars['ID'];
+  readonly maker: Scalars['String'];
+  readonly marketplace: NftMarketplace;
+  readonly marketplaceUrl: Scalars['String'];
+  readonly orderHash?: Maybe<Scalars['String']>;
+  readonly poolPrices?: Maybe<ReadonlyArray<Scalars['String']>>;
+  readonly price: Amount;
+  readonly protocolParameters?: Maybe<Scalars['AWSJSON']>;
+  readonly quantity: Scalars['Int'];
+  readonly startAt: Scalars['Float'];
+  readonly status: OrderStatus;
+  readonly taker?: Maybe<Scalars['String']>;
+  readonly tokenId?: Maybe<Scalars['String']>;
+  readonly type: OrderType;
+};
+
+export type NftOrderConnection = {
+  readonly __typename?: 'NftOrderConnection';
+  readonly edges: ReadonlyArray<NftOrderEdge>;
+  readonly pageInfo: PageInfo;
+};
+
+export type NftOrderEdge = {
+  readonly __typename?: 'NftOrderEdge';
+  readonly cursor: Scalars['String'];
+  readonly node: NftOrder;
+};
+
+export type NftProfile = {
+  readonly __typename?: 'NftProfile';
+  readonly address: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly isVerified?: Maybe<Scalars['Boolean']>;
+  readonly profileImage?: Maybe<Image>;
+  readonly username?: Maybe<Scalars['String']>;
+};
+
+export enum NftRarityProvider {
+  RaritySniper = 'RARITY_SNIPER'
+}
+
+export type NftRouteResponse = {
+  readonly __typename?: 'NftRouteResponse';
+  readonly calldata: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly route?: Maybe<ReadonlyArray<NftTrade>>;
+  readonly sendAmount: TokenAmount;
+  readonly toAddress: Scalars['String'];
+};
+
+export enum NftStandard {
+  Erc721 = 'ERC721',
+  Erc1155 = 'ERC1155',
+  Noncompliant = 'NONCOMPLIANT'
+}
+
+export type NftTrade = {
+  readonly __typename?: 'NftTrade';
+  readonly amount: Scalars['Int'];
+  readonly contractAddress: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly marketplace: NftMarketplace;
+  /**   price represents the current price of the NFT, which can be different from quotePrice */
+  readonly price: TokenAmount;
+  /**   quotePrice represents the last quoted price of the NFT */
+  readonly quotePrice?: Maybe<TokenAmount>;
+  readonly tokenId: Scalars['String'];
+  readonly tokenType?: Maybe<NftStandard>;
+};
+
+export type NftTradeInput = {
+  readonly amount: Scalars['Int'];
+  readonly contractAddress: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly marketplace: NftMarketplace;
+  readonly quotePrice?: InputMaybe<TokenAmountInput>;
+  readonly tokenId: Scalars['String'];
+  readonly tokenType?: InputMaybe<NftStandard>;
+};
+
+export type NftTransfer = {
+  readonly __typename?: 'NftTransfer';
+  readonly asset: NftAsset;
+  readonly direction: TransactionDirection;
+  readonly id: Scalars['ID'];
+  readonly nftStandard: NftStandard;
+  readonly recipient: Scalars['String'];
+  readonly sender: Scalars['String'];
+};
+
+export enum OrderStatus {
+  Cancelled = 'CANCELLED',
+  Executed = 'EXECUTED',
+  Expired = 'EXPIRED',
+  Valid = 'VALID'
+}
+
+export enum OrderType {
+  Listing = 'LISTING',
+  Offer = 'OFFER'
+}
+
+export type PageInfo = {
+  readonly __typename?: 'PageInfo';
+  readonly endCursor?: Maybe<Scalars['String']>;
+  readonly hasNextPage?: Maybe<Scalars['Boolean']>;
+  readonly hasPreviousPage?: Maybe<Scalars['Boolean']>;
+  readonly startCursor?: Maybe<Scalars['String']>;
+};
+
+/**   v2 pool parameters as defined by https://github.com/Uniswap/v2-sdk/blob/main/src/entities/pair.ts */
+export type PairInput = {
+  readonly tokenAmountA: TokenAmountInput;
+  readonly tokenAmountB: TokenAmountInput;
+};
+
+export type PermitDetailsInput = {
+  readonly amount: Scalars['String'];
+  readonly expiration: Scalars['String'];
+  readonly nonce: Scalars['String'];
+  readonly token: Scalars['String'];
+};
+
+export type PermitInput = {
+  readonly details: PermitDetailsInput;
+  readonly sigDeadline: Scalars['String'];
+  readonly signature: Scalars['String'];
+  readonly spender: Scalars['String'];
+};
+
+/**   v3 pool parameters as defined by https://github.com/Uniswap/v3-sdk/blob/main/src/entities/pool.ts */
+export type PoolInput = {
+  readonly fee: Scalars['Int'];
+  readonly liquidity: Scalars['String'];
+  readonly sqrtRatioX96: Scalars['String'];
+  readonly tickCurrent: Scalars['String'];
+  readonly tokenA: TokenInput;
+  readonly tokenB: TokenInput;
+};
+
+export type Portfolio = {
+  readonly __typename?: 'Portfolio';
+  readonly assetActivities?: Maybe<ReadonlyArray<Maybe<AssetActivity>>>;
+  readonly id: Scalars['ID'];
+  /**   TODO: (michael.zhang) replace with paginated query */
+  readonly nftBalances?: Maybe<ReadonlyArray<Maybe<NftBalance>>>;
+  readonly ownerAddress: Scalars['String'];
+  readonly tokenBalances?: Maybe<ReadonlyArray<Maybe<TokenBalance>>>;
+  readonly tokensTotalDenominatedValue?: Maybe<Amount>;
+  readonly tokensTotalDenominatedValueChange?: Maybe<AmountChange>;
+};
+
+
+export type PortfolioAssetActivitiesArgs = {
+  chains?: InputMaybe<ReadonlyArray<Chain>>;
+  includeOffChain?: InputMaybe<Scalars['Boolean']>;
+  page?: InputMaybe<Scalars['Int']>;
+  pageSize?: InputMaybe<Scalars['Int']>;
+};
+
+
+export type PortfolioTokensTotalDenominatedValueChangeArgs = {
+  duration?: InputMaybe<HistoryDuration>;
+};
+
+export type Query = {
+  readonly __typename?: 'Query';
+  readonly convert?: Maybe<Amount>;
+  readonly nftActivity?: Maybe<NftActivityConnection>;
+  readonly nftAssets?: Maybe<NftAssetConnection>;
+  readonly nftBalances?: Maybe<NftBalanceConnection>;
+  readonly nftCollectionBalances?: Maybe<NftCollectionBalanceConnection>;
+  readonly nftCollections?: Maybe<NftCollectionConnection>;
+  readonly nftRoute?: Maybe<NftRouteResponse>;
+  readonly portfolios?: Maybe<ReadonlyArray<Maybe<Portfolio>>>;
+  readonly searchTokens?: Maybe<ReadonlyArray<Maybe<Token>>>;
+  readonly token?: Maybe<Token>;
+  readonly tokenProjects?: Maybe<ReadonlyArray<Maybe<TokenProject>>>;
+  readonly tokens?: Maybe<ReadonlyArray<Maybe<Token>>>;
+  readonly topCollections?: Maybe<NftCollectionConnection>;
+  readonly topTokens?: Maybe<ReadonlyArray<Maybe<Token>>>;
+};
+
+
+export type QueryConvertArgs = {
+  fromAmount: AmountInput;
+  toCurrency: Currency;
+};
+
+
+export type QueryNftActivityArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  filter?: InputMaybe<NftActivityFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+};
+
+
+export type QueryNftAssetsArgs = {
+  address: Scalars['String'];
+  after?: InputMaybe<Scalars['String']>;
+  asc?: InputMaybe<Scalars['Boolean']>;
+  before?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  filter?: InputMaybe<NftAssetsFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+  last?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<NftAssetSortableField>;
+};
+
+
+export type QueryNftBalancesArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  before?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  filter?: InputMaybe<NftBalancesFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+  last?: InputMaybe<Scalars['Int']>;
+  ownerAddress: Scalars['String'];
+};
+
+
+export type QueryNftCollectionBalancesArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  before?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  first?: InputMaybe<Scalars['Int']>;
+  last?: InputMaybe<Scalars['Int']>;
+  ownerAddress: Scalars['String'];
+};
+
+
+export type QueryNftCollectionsArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  chain?: InputMaybe<Chain>;
+  filter?: InputMaybe<NftCollectionsFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+};
+
+
+export type QueryNftRouteArgs = {
+  chain?: InputMaybe<Chain>;
+  nftTrades: ReadonlyArray<NftTradeInput>;
+  senderAddress: Scalars['String'];
+  tokenTrades?: InputMaybe<ReadonlyArray<TokenTradeInput>>;
+};
+
+
+export type QueryPortfoliosArgs = {
+  chains?: InputMaybe<ReadonlyArray<Chain>>;
+  lookupTokens?: InputMaybe<ReadonlyArray<ContractInput>>;
+  ownerAddresses: ReadonlyArray<Scalars['String']>;
+};
+
+
+export type QuerySearchTokensArgs = {
+  chains?: InputMaybe<ReadonlyArray<Chain>>;
+  searchQuery: Scalars['String'];
+};
+
+
+export type QueryTokenArgs = {
+  address?: InputMaybe<Scalars['String']>;
+  chain: Chain;
+};
+
+
+export type QueryTokenProjectsArgs = {
+  contracts: ReadonlyArray<ContractInput>;
+};
+
+
+export type QueryTokensArgs = {
+  contracts: ReadonlyArray<ContractInput>;
+};
+
+
+export type QueryTopCollectionsArgs = {
+  after?: InputMaybe<Scalars['String']>;
+  chains?: InputMaybe<ReadonlyArray<Chain>>;
+  cursor?: InputMaybe<Scalars['String']>;
+  duration?: InputMaybe<HistoryDuration>;
+  first?: InputMaybe<Scalars['Int']>;
+  limit?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<CollectionSortableField>;
+};
+
+
+export type QueryTopTokensArgs = {
+  chain?: InputMaybe<Chain>;
+  orderBy?: InputMaybe<TokenSortableField>;
+  page?: InputMaybe<Scalars['Int']>;
+  pageSize?: InputMaybe<Scalars['Int']>;
+};
+
+export enum SafetyLevel {
+  Blocked = 'BLOCKED',
+  MediumWarning = 'MEDIUM_WARNING',
+  StrongWarning = 'STRONG_WARNING',
+  Verified = 'VERIFIED'
+}
+
+export type SwapOrderDetails = {
+  readonly __typename?: 'SwapOrderDetails';
+  readonly hash: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly inputToken: Token;
+  readonly inputTokenQuantity: Scalars['String'];
+  readonly offerer: Scalars['String'];
+  readonly outputToken: Token;
+  readonly outputTokenQuantity: Scalars['String'];
+  readonly status: SwapOrderStatus;
+};
+
+export enum SwapOrderStatus {
+  Error = 'ERROR',
+  Expired = 'EXPIRED',
+  InsufficientFunds = 'INSUFFICIENT_FUNDS',
+  Open = 'OPEN'
+}
+
+export type TimestampedAmount = IAmount & {
+  readonly __typename?: 'TimestampedAmount';
+  readonly currency?: Maybe<Currency>;
+  readonly id: Scalars['ID'];
+  readonly timestamp: Scalars['Int'];
+  readonly value: Scalars['Float'];
+};
+
+export type Token = IContract & {
+  readonly __typename?: 'Token';
+  readonly address?: Maybe<Scalars['String']>;
+  readonly chain: Chain;
+  readonly decimals?: Maybe<Scalars['Int']>;
+  readonly id: Scalars['ID'];
+  readonly market?: Maybe<TokenMarket>;
+  readonly name?: Maybe<Scalars['String']>;
+  readonly project?: Maybe<TokenProject>;
+  readonly standard?: Maybe<TokenStandard>;
+  readonly symbol?: Maybe<Scalars['String']>;
+};
+
+
+export type TokenMarketArgs = {
+  currency?: InputMaybe<Currency>;
+};
+
+export type TokenAmount = {
+  readonly __typename?: 'TokenAmount';
+  readonly currency: Currency;
+  readonly id: Scalars['ID'];
+  readonly value: Scalars['String'];
+};
+
+export type TokenAmountInput = {
+  readonly amount: Scalars['String'];
+  readonly token: TokenInput;
+};
+
+export type TokenApproval = {
+  readonly __typename?: 'TokenApproval';
+  readonly approvedAddress: Scalars['String'];
+  /**   can be erc20 or native */
+  readonly asset: Token;
+  readonly id: Scalars['ID'];
+  readonly quantity: Scalars['String'];
+  readonly tokenStandard: TokenStandard;
+};
+
+export type TokenBalance = {
+  readonly __typename?: 'TokenBalance';
+  readonly blockNumber?: Maybe<Scalars['Int']>;
+  readonly blockTimestamp?: Maybe<Scalars['Int']>;
+  readonly denominatedValue?: Maybe<Amount>;
+  readonly id: Scalars['ID'];
+  readonly ownerAddress: Scalars['String'];
+  readonly quantity?: Maybe<Scalars['Float']>;
+  readonly token?: Maybe<Token>;
+  readonly tokenProjectMarket?: Maybe<TokenProjectMarket>;
+};
+
+export type TokenInput = {
+  readonly address: Scalars['String'];
+  readonly chainId: Scalars['Int'];
+  readonly decimals: Scalars['Int'];
+  readonly isNative: Scalars['Boolean'];
+};
+
+export type TokenMarket = {
+  readonly __typename?: 'TokenMarket';
+  readonly id: Scalars['ID'];
+  readonly price?: Maybe<Amount>;
+  readonly priceHighLow?: Maybe<Amount>;
+  readonly priceHistory?: Maybe<ReadonlyArray<Maybe<TimestampedAmount>>>;
+  readonly pricePercentChange?: Maybe<Amount>;
+  readonly token: Token;
+  readonly totalValueLocked?: Maybe<Amount>;
+  readonly volume?: Maybe<Amount>;
+};
+
+
+export type TokenMarketPriceHighLowArgs = {
+  duration: HistoryDuration;
+  highLow: HighLow;
+};
+
+
+export type TokenMarketPriceHistoryArgs = {
+  duration: HistoryDuration;
+};
+
+
+export type TokenMarketPricePercentChangeArgs = {
+  duration: HistoryDuration;
+};
+
+
+export type TokenMarketVolumeArgs = {
+  duration: HistoryDuration;
+};
+
+export type TokenProject = {
+  readonly __typename?: 'TokenProject';
+  readonly description?: Maybe<Scalars['String']>;
+  readonly homepageUrl?: Maybe<Scalars['String']>;
+  readonly id: Scalars['ID'];
+  readonly isSpam?: Maybe<Scalars['Boolean']>;
+  readonly logo?: Maybe<Image>;
+  /** @deprecated use logo */
+  readonly logoUrl?: Maybe<Scalars['String']>;
+  readonly markets?: Maybe<ReadonlyArray<Maybe<TokenProjectMarket>>>;
+  readonly name?: Maybe<Scalars['String']>;
+  readonly safetyLevel?: Maybe<SafetyLevel>;
+  /** @deprecated use logo */
+  readonly smallLogo?: Maybe<Image>;
+  readonly spamCode?: Maybe<Scalars['Int']>;
+  readonly tokens: ReadonlyArray<Token>;
+  readonly twitterName?: Maybe<Scalars['String']>;
+};
+
+
+export type TokenProjectMarketsArgs = {
+  currencies: ReadonlyArray<Currency>;
+};
+
+export type TokenProjectMarket = {
+  readonly __typename?: 'TokenProjectMarket';
+  readonly currency: Currency;
+  readonly id: Scalars['ID'];
+  readonly marketCap?: Maybe<Amount>;
+  readonly price?: Maybe<Amount>;
+  readonly priceHigh52w?: Maybe<Amount>;
+  readonly priceHighLow?: Maybe<Amount>;
+  readonly priceHistory?: Maybe<ReadonlyArray<Maybe<TimestampedAmount>>>;
+  readonly priceLow52w?: Maybe<Amount>;
+  readonly pricePercentChange?: Maybe<Amount>;
+  readonly pricePercentChange24h?: Maybe<Amount>;
+  readonly tokenProject: TokenProject;
+};
+
+
+export type TokenProjectMarketPriceHighLowArgs = {
+  duration: HistoryDuration;
+  highLow: HighLow;
+};
+
+
+export type TokenProjectMarketPriceHistoryArgs = {
+  duration: HistoryDuration;
+};
+
+
+export type TokenProjectMarketPricePercentChangeArgs = {
+  duration: HistoryDuration;
+};
+
+export enum TokenSortableField {
+  MarketCap = 'MARKET_CAP',
+  Popularity = 'POPULARITY',
+  TotalValueLocked = 'TOTAL_VALUE_LOCKED',
+  Volume = 'VOLUME'
+}
+
+export enum TokenStandard {
+  Erc20 = 'ERC20',
+  Native = 'NATIVE'
+}
+
+export type TokenTradeInput = {
+  readonly permit?: InputMaybe<PermitInput>;
+  readonly routes?: InputMaybe<TokenTradeRoutesInput>;
+  readonly slippageToleranceBasisPoints?: InputMaybe<Scalars['Int']>;
+  readonly tokenAmount: TokenAmountInput;
+};
+
+export type TokenTradeRouteInput = {
+  readonly inputAmount: TokenAmountInput;
+  readonly outputAmount: TokenAmountInput;
+  readonly pools: ReadonlyArray<TradePoolInput>;
+};
+
+export type TokenTradeRoutesInput = {
+  readonly mixedRoutes?: InputMaybe<ReadonlyArray<TokenTradeRouteInput>>;
+  readonly tradeType: TokenTradeType;
+  readonly v2Routes?: InputMaybe<ReadonlyArray<TokenTradeRouteInput>>;
+  readonly v3Routes?: InputMaybe<ReadonlyArray<TokenTradeRouteInput>>;
+};
+
+export enum TokenTradeType {
+  ExactInput = 'EXACT_INPUT',
+  ExactOutput = 'EXACT_OUTPUT'
+}
+
+export type TokenTransfer = {
+  readonly __typename?: 'TokenTransfer';
+  readonly asset: Token;
+  readonly direction: TransactionDirection;
+  readonly id: Scalars['ID'];
+  readonly quantity: Scalars['String'];
+  readonly recipient: Scalars['String'];
+  readonly sender: Scalars['String'];
+  readonly tokenStandard: TokenStandard;
+  readonly transactedValue?: Maybe<Amount>;
+};
+
+export type TradePoolInput = {
+  readonly pair?: InputMaybe<PairInput>;
+  readonly pool?: InputMaybe<PoolInput>;
+};
+
+export type Transaction = {
+  readonly __typename?: 'Transaction';
+  readonly blockNumber: Scalars['Int'];
+  readonly from: Scalars['String'];
+  readonly gasLimit?: Maybe<Scalars['Float']>;
+  readonly hash: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly maxFeePerGas?: Maybe<Scalars['Float']>;
+  readonly nonce: Scalars['Int'];
+  readonly status: TransactionStatus;
+  readonly to: Scalars['String'];
+};
+
+export type TransactionDetails = {
+  readonly __typename?: 'TransactionDetails';
+  readonly assetChanges: ReadonlyArray<Maybe<AssetChange>>;
+  readonly from: Scalars['String'];
+  readonly hash: Scalars['String'];
+  readonly id: Scalars['ID'];
+  readonly nonce: Scalars['Int'];
+  readonly status: TransactionStatus;
+  readonly to: Scalars['String'];
+  readonly type: TransactionType;
+};
+
+export enum TransactionDirection {
+  In = 'IN',
+  Out = 'OUT',
+  Self = 'SELF'
+}
+
+export enum TransactionStatus {
+  Confirmed = 'CONFIRMED',
+  Failed = 'FAILED',
+  Pending = 'PENDING'
+}
+
+export enum TransactionType {
+  Approve = 'APPROVE',
+  Borrow = 'BORROW',
+  Cancel = 'CANCEL',
+  Claim = 'CLAIM',
+  Deployment = 'DEPLOYMENT',
+  Lend = 'LEND',
+  Mint = 'MINT',
+  Receive = 'RECEIVE',
+  Repay = 'REPAY',
+  Send = 'SEND',
+  Stake = 'STAKE',
+  Swap = 'SWAP',
+  SwapOrder = 'SWAP_ORDER',
+  Unknown = 'UNKNOWN',
+  Unstake = 'UNSTAKE',
+  Withdraw = 'WITHDRAW'
+}
+
+export type ConvertQueryVariables = Exact<{
+  toCurrency: Currency;
+}>;
+
+
+export type ConvertQuery = { readonly __typename?: 'Query', readonly convert?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } };
+
+export type RecentlySearchedAssetsQueryVariables = Exact<{
+  collectionAddresses: ReadonlyArray<Scalars['String']> | Scalars['String'];
+  contracts: ReadonlyArray<ContractInput> | ContractInput;
+}>;
+
+
+export type RecentlySearchedAssetsQuery = { readonly __typename?: 'Query', readonly nftCollections?: { readonly __typename?: 'NftCollectionConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftCollectionEdge', readonly node: { readonly __typename?: 'NftCollection', readonly collectionId: string, readonly isVerified?: boolean, readonly name?: string, readonly numAssets?: number, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string }>, readonly markets?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarket', readonly floorPrice?: { readonly __typename?: 'TimestampedAmount', readonly currency?: Currency, readonly value: number } }> } }> }, readonly tokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly decimals?: number, readonly name?: string, readonly chain: Chain, readonly standard?: TokenStandard, readonly address?: string, readonly symbol?: string, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly pricePercentChange?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly volume24H?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } }, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly logoUrl?: string, readonly safetyLevel?: SafetyLevel } }> };
+
+export type SearchTokensQueryVariables = Exact<{
+  searchQuery: Scalars['String'];
+}>;
+
+
+export type SearchTokensQuery = { readonly __typename?: 'Query', readonly searchTokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly decimals?: number, readonly name?: string, readonly chain: Chain, readonly standard?: TokenStandard, readonly address?: string, readonly symbol?: string, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly pricePercentChange?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly volume24H?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } }, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly logoUrl?: string, readonly safetyLevel?: SafetyLevel } }> };
+
+export type TokenQueryVariables = Exact<{
+  chain: Chain;
+  address?: InputMaybe<Scalars['String']>;
+}>;
+
+
+export type TokenQuery = { readonly __typename?: 'Query', readonly token?: { readonly __typename?: 'Token', readonly id: string, readonly decimals?: number, readonly name?: string, readonly chain: Chain, readonly address?: string, readonly symbol?: string, readonly standard?: TokenStandard, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly totalValueLocked?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly volume24H?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly priceHigh52W?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly priceLow52W?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number } }, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly description?: string, readonly homepageUrl?: string, readonly twitterName?: string, readonly logoUrl?: string, readonly tokens: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly chain: Chain, readonly address?: string }> } } };
+
+export type TokenProjectQueryVariables = Exact<{
+  chain: Chain;
+  address?: InputMaybe<Scalars['String']>;
+}>;
+
+
+export type TokenProjectQuery = { readonly __typename?: 'Query', readonly token?: { readonly __typename?: 'Token', readonly id: string, readonly decimals?: number, readonly name?: string, readonly chain: Chain, readonly address?: string, readonly symbol?: string, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly description?: string, readonly homepageUrl?: string, readonly twitterName?: string, readonly logoUrl?: string, readonly tokens: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly chain: Chain, readonly address?: string }> } } };
+
+export type TokenPriceQueryVariables = Exact<{
+  chain: Chain;
+  address?: InputMaybe<Scalars['String']>;
+  duration: HistoryDuration;
+}>;
+
+
+export type TokenPriceQuery = { readonly __typename?: 'Query', readonly token?: { readonly __typename?: 'Token', readonly id: string, readonly address?: string, readonly chain: Chain, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly priceHistory?: ReadonlyArray<{ readonly __typename?: 'TimestampedAmount', readonly id: string, readonly timestamp: number, readonly value: number }> } } };
+
+export type UniswapPricesQueryVariables = Exact<{
+  contracts: ReadonlyArray<ContractInput> | ContractInput;
+}>;
+
+
+export type UniswapPricesQuery = { readonly __typename?: 'Query', readonly tokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly address?: string, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly markets?: ReadonlyArray<{ readonly __typename?: 'TokenProjectMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number } }> } }> };
+
+export type TokenSpotPriceQueryVariables = Exact<{
+  chain: Chain;
+  address?: InputMaybe<Scalars['String']>;
+}>;
+
+
+export type TokenSpotPriceQuery = { readonly __typename?: 'Query', readonly token?: { readonly __typename?: 'Token', readonly id: string, readonly address?: string, readonly chain: Chain, readonly name?: string, readonly symbol?: string, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly markets?: ReadonlyArray<{ readonly __typename?: 'TokenProjectMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number } }> } } };
+
+export type TopTokens100QueryVariables = Exact<{
+  duration: HistoryDuration;
+  chain: Chain;
+}>;
+
+
+export type TopTokens100Query = { readonly __typename?: 'Query', readonly topTokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly chain: Chain, readonly address?: string, readonly symbol?: string, readonly standard?: TokenStandard, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly totalValueLocked?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly pricePercentChange?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number }, readonly volume?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } }, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly logoUrl?: string } }> };
+
+export type TopTokensSparklineQueryVariables = Exact<{
+  duration: HistoryDuration;
+  chain: Chain;
+}>;
+
+
+export type TopTokensSparklineQuery = { readonly __typename?: 'Query', readonly topTokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly address?: string, readonly chain: Chain, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly priceHistory?: ReadonlyArray<{ readonly __typename?: 'TimestampedAmount', readonly id: string, readonly timestamp: number, readonly value: number }> } }> };
+
+export type TrendingTokensQueryVariables = Exact<{
+  chain: Chain;
+}>;
+
+
+export type TrendingTokensQuery = { readonly __typename?: 'Query', readonly topTokens?: ReadonlyArray<{ readonly __typename?: 'Token', readonly id: string, readonly decimals?: number, readonly name?: string, readonly chain: Chain, readonly standard?: TokenStandard, readonly address?: string, readonly symbol?: string, readonly market?: { readonly __typename?: 'TokenMarket', readonly id: string, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency }, readonly pricePercentChange?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly volume24H?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } }, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly logoUrl?: string, readonly safetyLevel?: SafetyLevel } }> };
+
+export type NftAssetPartsFragment = { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } };
+
+export type NftTransferPartsFragment = { readonly __typename?: 'NftTransfer', readonly id: string, readonly nftStandard: NftStandard, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } };
+
+export type TokenAssetPartsFragment = { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } };
+
+export type TokenTransferPartsFragment = { readonly __typename?: 'TokenTransfer', readonly id: string, readonly tokenStandard: TokenStandard, readonly quantity: string, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly transactedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number } };
+
+export type TokenApprovalPartsFragment = { readonly __typename?: 'TokenApproval', readonly id: string, readonly tokenStandard: TokenStandard, readonly approvedAddress: string, readonly quantity: string, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } };
+
+export type NftApprovalPartsFragment = { readonly __typename?: 'NftApproval', readonly id: string, readonly nftStandard: NftStandard, readonly approvedAddress: string, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } };
+
+export type NftApproveForAllPartsFragment = { readonly __typename?: 'NftApproveForAll', readonly id: string, readonly nftStandard: NftStandard, readonly operatorAddress: string, readonly approved: boolean, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } };
+
+export type TransactionPartsFragment = { readonly __typename?: 'Transaction', readonly id: string, readonly blockNumber: number, readonly hash: string, readonly status: TransactionStatus, readonly to: string, readonly from: string, readonly nonce: number };
+
+export type TransactionDetailsPartsFragment = { readonly __typename?: 'TransactionDetails', readonly id: string, readonly type: TransactionType, readonly from: string, readonly to: string, readonly hash: string, readonly nonce: number, readonly status: TransactionStatus, readonly assetChanges: ReadonlyArray<{ readonly __typename: 'NftApproval', readonly id: string, readonly nftStandard: NftStandard, readonly approvedAddress: string, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftApproveForAll', readonly id: string, readonly nftStandard: NftStandard, readonly operatorAddress: string, readonly approved: boolean, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftTransfer', readonly id: string, readonly nftStandard: NftStandard, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'TokenApproval', readonly id: string, readonly tokenStandard: TokenStandard, readonly approvedAddress: string, readonly quantity: string, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } } | { readonly __typename: 'TokenTransfer', readonly id: string, readonly tokenStandard: TokenStandard, readonly quantity: string, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly transactedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number } }> };
+
+export type SwapOrderDetailsPartsFragment = { readonly __typename?: 'SwapOrderDetails', readonly id: string, readonly offerer: string, readonly hash: string, readonly inputTokenQuantity: string, readonly outputTokenQuantity: string, readonly orderStatus: SwapOrderStatus, readonly inputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly outputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } };
+
+export type AssetActivityPartsFragment = { readonly __typename?: 'AssetActivity', readonly id: string, readonly timestamp: number, readonly chain: Chain, readonly details: { readonly __typename: 'SwapOrderDetails', readonly id: string, readonly offerer: string, readonly hash: string, readonly inputTokenQuantity: string, readonly outputTokenQuantity: string, readonly orderStatus: SwapOrderStatus, readonly inputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly outputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } } | { readonly __typename: 'TransactionDetails', readonly id: string, readonly type: TransactionType, readonly from: string, readonly to: string, readonly hash: string, readonly nonce: number, readonly status: TransactionStatus, readonly assetChanges: ReadonlyArray<{ readonly __typename: 'NftApproval', readonly id: string, readonly nftStandard: NftStandard, readonly approvedAddress: string, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftApproveForAll', readonly id: string, readonly nftStandard: NftStandard, readonly operatorAddress: string, readonly approved: boolean, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftTransfer', readonly id: string, readonly nftStandard: NftStandard, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'TokenApproval', readonly id: string, readonly tokenStandard: TokenStandard, readonly approvedAddress: string, readonly quantity: string, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } } | { readonly __typename: 'TokenTransfer', readonly id: string, readonly tokenStandard: TokenStandard, readonly quantity: string, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly transactedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number } }> } };
+
+export type ActivityQueryVariables = Exact<{
+  account: Scalars['String'];
+}>;
+
+
+export type ActivityQuery = { readonly __typename?: 'Query', readonly portfolios?: ReadonlyArray<{ readonly __typename?: 'Portfolio', readonly id: string, readonly assetActivities?: ReadonlyArray<{ readonly __typename?: 'AssetActivity', readonly id: string, readonly timestamp: number, readonly chain: Chain, readonly details: { readonly __typename: 'SwapOrderDetails', readonly id: string, readonly offerer: string, readonly hash: string, readonly inputTokenQuantity: string, readonly outputTokenQuantity: string, readonly orderStatus: SwapOrderStatus, readonly inputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly outputToken: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } } | { readonly __typename: 'TransactionDetails', readonly id: string, readonly type: TransactionType, readonly from: string, readonly to: string, readonly hash: string, readonly nonce: number, readonly status: TransactionStatus, readonly assetChanges: ReadonlyArray<{ readonly __typename: 'NftApproval', readonly id: string, readonly nftStandard: NftStandard, readonly approvedAddress: string, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftApproveForAll', readonly id: string, readonly nftStandard: NftStandard, readonly operatorAddress: string, readonly approved: boolean, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'NftTransfer', readonly id: string, readonly nftStandard: NftStandard, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly chain: Chain, readonly address: string }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly name?: string } } } | { readonly __typename: 'TokenApproval', readonly id: string, readonly tokenStandard: TokenStandard, readonly approvedAddress: string, readonly quantity: string, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } } } | { readonly __typename: 'TokenTransfer', readonly id: string, readonly tokenStandard: TokenStandard, readonly quantity: string, readonly sender: string, readonly recipient: string, readonly direction: TransactionDirection, readonly asset: { readonly __typename?: 'Token', readonly id: string, readonly name?: string, readonly symbol?: string, readonly address?: string, readonly decimals?: number, readonly chain: Chain, readonly standard?: TokenStandard, readonly project?: { readonly __typename?: 'TokenProject', readonly id: string, readonly isSpam?: boolean, readonly logo?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly transactedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number } }> } }> }> };
+
+export type AssetQueryVariables = Exact<{
+  address: Scalars['String'];
+  orderBy?: InputMaybe<NftAssetSortableField>;
+  asc?: InputMaybe<Scalars['Boolean']>;
+  filter?: InputMaybe<NftAssetsFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+  after?: InputMaybe<Scalars['String']>;
+  last?: InputMaybe<Scalars['Int']>;
+  before?: InputMaybe<Scalars['String']>;
+}>;
+
+
+export type AssetQuery = { readonly __typename?: 'Query', readonly nftAssets?: { readonly __typename?: 'NftAssetConnection', readonly totalCount?: number, readonly edges: ReadonlyArray<{ readonly __typename?: 'NftAssetEdge', readonly cursor: string, readonly node: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly tokenId: string, readonly animationUrl?: string, readonly suspiciousFlag?: boolean, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly smallImage?: { readonly __typename?: 'Image', readonly url: string }, readonly collection?: { readonly __typename?: 'NftCollection', readonly name?: string, readonly isVerified?: boolean, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string, readonly standard?: NftStandard }> }, readonly listings?: { readonly __typename?: 'NftOrderConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftOrderEdge', readonly cursor: string, readonly node: { readonly __typename?: 'NftOrder', readonly address: string, readonly createdAt: number, readonly endAt?: number, readonly id: string, readonly maker: string, readonly marketplace: NftMarketplace, readonly marketplaceUrl: string, readonly orderHash?: string, readonly quantity: number, readonly startAt: number, readonly status: OrderStatus, readonly taker?: string, readonly tokenId?: string, readonly type: OrderType, readonly protocolParameters?: any, readonly price: { readonly __typename?: 'Amount', readonly currency?: Currency, readonly value: number } } }> }, readonly rarities?: ReadonlyArray<{ readonly __typename?: 'NftAssetRarity', readonly rank?: number }> } }>, readonly pageInfo: { readonly __typename?: 'PageInfo', readonly endCursor?: string, readonly hasNextPage?: boolean, readonly hasPreviousPage?: boolean, readonly startCursor?: string } } };
+
+export type CollectionQueryVariables = Exact<{
+  addresses: ReadonlyArray<Scalars['String']> | Scalars['String'];
+}>;
+
+
+export type CollectionQuery = { readonly __typename?: 'Query', readonly nftCollections?: { readonly __typename?: 'NftCollectionConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftCollectionEdge', readonly cursor: string, readonly node: { readonly __typename?: 'NftCollection', readonly collectionId: string, readonly description?: string, readonly discordUrl?: string, readonly homepageUrl?: string, readonly instagramName?: string, readonly isVerified?: boolean, readonly name?: string, readonly numAssets?: number, readonly twitterName?: string, readonly bannerImage?: { readonly __typename?: 'Image', readonly url: string }, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string, readonly chain: Chain, readonly name?: string, readonly standard?: NftStandard, readonly symbol?: string, readonly totalSupply?: number }>, readonly traits?: ReadonlyArray<{ readonly __typename?: 'NftCollectionTrait', readonly name?: string, readonly values?: ReadonlyArray<string>, readonly stats?: ReadonlyArray<{ readonly __typename?: 'NftCollectionTraitStats', readonly name?: string, readonly value?: string, readonly assets?: number, readonly listings?: number }> }>, readonly markets?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarket', readonly owners?: number, readonly floorPrice?: { readonly __typename?: 'TimestampedAmount', readonly currency?: Currency, readonly value: number }, readonly totalVolume?: { readonly __typename?: 'TimestampedAmount', readonly value: number, readonly currency?: Currency }, readonly listings?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly volume?: { readonly __typename?: 'TimestampedAmount', readonly value: number, readonly currency?: Currency }, readonly volumePercentChange?: { readonly __typename?: 'TimestampedAmount', readonly value: number, readonly currency?: Currency }, readonly floorPricePercentChange?: { readonly __typename?: 'TimestampedAmount', readonly value: number, readonly currency?: Currency }, readonly marketplaces?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarketplace', readonly marketplace?: NftMarketplace, readonly listings?: number, readonly floorPrice?: number }> }> } }>, readonly pageInfo: { readonly __typename?: 'PageInfo', readonly endCursor?: string, readonly hasNextPage?: boolean, readonly hasPreviousPage?: boolean, readonly startCursor?: string } } };
+
+export type CollectionSearchQueryVariables = Exact<{
+  query: Scalars['String'];
+}>;
+
+
+export type CollectionSearchQuery = { readonly __typename?: 'Query', readonly nftCollections?: { readonly __typename?: 'NftCollectionConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftCollectionEdge', readonly cursor: string, readonly node: { readonly __typename?: 'NftCollection', readonly isVerified?: boolean, readonly name?: string, readonly numAssets?: number, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string, readonly chain: Chain, readonly name?: string, readonly symbol?: string, readonly totalSupply?: number }>, readonly markets?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarket', readonly floorPrice?: { readonly __typename?: 'TimestampedAmount', readonly currency?: Currency, readonly value: number } }> } }>, readonly pageInfo: { readonly __typename?: 'PageInfo', readonly endCursor?: string, readonly hasNextPage?: boolean, readonly hasPreviousPage?: boolean, readonly startCursor?: string } } };
+
+export type DetailsQueryVariables = Exact<{
+  address: Scalars['String'];
+  tokenId: Scalars['String'];
+}>;
+
+
+export type DetailsQuery = { readonly __typename?: 'Query', readonly nftAssets?: { readonly __typename?: 'NftAssetConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftAssetEdge', readonly node: { readonly __typename?: 'NftAsset', readonly id: string, readonly name?: string, readonly ownerAddress?: string, readonly tokenId: string, readonly description?: string, readonly animationUrl?: string, readonly suspiciousFlag?: boolean, readonly metadataUrl?: string, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly smallImage?: { readonly __typename?: 'Image', readonly url: string }, readonly originalImage?: { readonly __typename?: 'Image', readonly url: string }, readonly creator?: { readonly __typename?: 'NftProfile', readonly address: string, readonly isVerified?: boolean, readonly profileImage?: { readonly __typename?: 'Image', readonly url: string } }, readonly collection?: { readonly __typename?: 'NftCollection', readonly name?: string, readonly isVerified?: boolean, readonly numAssets?: number, readonly twitterName?: string, readonly discordUrl?: string, readonly homepageUrl?: string, readonly description?: string, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string, readonly standard?: NftStandard }> }, readonly listings?: { readonly __typename?: 'NftOrderConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftOrderEdge', readonly cursor: string, readonly node: { readonly __typename?: 'NftOrder', readonly address: string, readonly createdAt: number, readonly endAt?: number, readonly id: string, readonly maker: string, readonly marketplace: NftMarketplace, readonly marketplaceUrl: string, readonly orderHash?: string, readonly quantity: number, readonly startAt: number, readonly status: OrderStatus, readonly taker?: string, readonly tokenId?: string, readonly type: OrderType, readonly protocolParameters?: any, readonly price: { readonly __typename?: 'Amount', readonly currency?: Currency, readonly value: number } } }> }, readonly rarities?: ReadonlyArray<{ readonly __typename?: 'NftAssetRarity', readonly provider?: NftRarityProvider, readonly rank?: number, readonly score?: number }>, readonly traits?: ReadonlyArray<{ readonly __typename?: 'NftAssetTrait', readonly name?: string, readonly value?: string }> } }> } };
+
+export type NftActivityQueryVariables = Exact<{
+  filter?: InputMaybe<NftActivityFilterInput>;
+  after?: InputMaybe<Scalars['String']>;
+  first?: InputMaybe<Scalars['Int']>;
+}>;
+
+
+export type NftActivityQuery = { readonly __typename?: 'Query', readonly nftActivity?: { readonly __typename?: 'NftActivityConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftActivityEdge', readonly node: { readonly __typename?: 'NftActivity', readonly id: string, readonly address: string, readonly tokenId?: string, readonly type: NftActivityType, readonly marketplace?: string, readonly fromAddress: string, readonly toAddress?: string, readonly transactionHash?: string, readonly orderStatus?: OrderStatus, readonly quantity?: number, readonly url?: string, readonly timestamp: number, readonly asset?: { readonly __typename?: 'NftAsset', readonly id: string, readonly metadataUrl?: string, readonly name?: string, readonly suspiciousFlag?: boolean, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly smallImage?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly rarities?: ReadonlyArray<{ readonly __typename?: 'NftAssetRarity', readonly id: string, readonly provider?: NftRarityProvider, readonly rank?: number, readonly score?: number }>, readonly nftContract?: { readonly __typename?: 'NftContract', readonly id: string, readonly standard?: NftStandard }, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string } } }, readonly price?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number } } }>, readonly pageInfo: { readonly __typename?: 'PageInfo', readonly endCursor?: string, readonly hasNextPage?: boolean, readonly hasPreviousPage?: boolean, readonly startCursor?: string } } };
+
+export type NftBalanceQueryVariables = Exact<{
+  ownerAddress: Scalars['String'];
+  filter?: InputMaybe<NftBalancesFilterInput>;
+  first?: InputMaybe<Scalars['Int']>;
+  after?: InputMaybe<Scalars['String']>;
+  last?: InputMaybe<Scalars['Int']>;
+  before?: InputMaybe<Scalars['String']>;
+}>;
+
+
+export type NftBalanceQuery = { readonly __typename?: 'Query', readonly nftBalances?: { readonly __typename?: 'NftBalanceConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftBalanceEdge', readonly node: { readonly __typename?: 'NftBalance', readonly listedMarketplaces?: ReadonlyArray<NftMarketplace>, readonly ownedAsset?: { readonly __typename?: 'NftAsset', readonly id: string, readonly animationUrl?: string, readonly description?: string, readonly flaggedBy?: string, readonly name?: string, readonly ownerAddress?: string, readonly suspiciousFlag?: boolean, readonly tokenId: string, readonly collection?: { readonly __typename?: 'NftCollection', readonly id: string, readonly isVerified?: boolean, readonly name?: string, readonly twitterName?: string, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly id: string, readonly address: string, readonly chain: Chain, readonly name?: string, readonly standard?: NftStandard, readonly symbol?: string, readonly totalSupply?: number }>, readonly markets?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarket', readonly id: string, readonly floorPrice?: { readonly __typename?: 'TimestampedAmount', readonly id: string, readonly value: number } }> }, readonly image?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly originalImage?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly smallImage?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly thumbnail?: { readonly __typename?: 'Image', readonly id: string, readonly url: string }, readonly listings?: { readonly __typename?: 'NftOrderConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftOrderEdge', readonly node: { readonly __typename?: 'NftOrder', readonly createdAt: number, readonly marketplace: NftMarketplace, readonly endAt?: number, readonly price: { readonly __typename?: 'Amount', readonly id: string, readonly value: number, readonly currency?: Currency } } }> } }, readonly listingFees?: ReadonlyArray<{ readonly __typename?: 'NftFee', readonly id: string, readonly payoutAddress: string, readonly basisPoints: number }>, readonly lastPrice?: { readonly __typename?: 'TimestampedAmount', readonly id: string, readonly currency?: Currency, readonly timestamp: number, readonly value: number } } }>, readonly pageInfo: { readonly __typename?: 'PageInfo', readonly endCursor?: string, readonly hasNextPage?: boolean, readonly hasPreviousPage?: boolean, readonly startCursor?: string } } };
+
+export type NftUniversalRouterAddressQueryVariables = Exact<{
+  chain?: InputMaybe<Chain>;
+}>;
+
+
+export type NftUniversalRouterAddressQuery = { readonly __typename?: 'Query', readonly nftRoute?: { readonly __typename?: 'NftRouteResponse', readonly toAddress: string } };
+
+export type NftRouteQueryVariables = Exact<{
+  chain?: InputMaybe<Chain>;
+  senderAddress: Scalars['String'];
+  nftTrades: ReadonlyArray<NftTradeInput> | NftTradeInput;
+  tokenTrades?: InputMaybe<ReadonlyArray<TokenTradeInput> | TokenTradeInput>;
+}>;
+
+
+export type NftRouteQuery = { readonly __typename?: 'Query', readonly nftRoute?: { readonly __typename?: 'NftRouteResponse', readonly id: string, readonly calldata: string, readonly toAddress: string, readonly route?: ReadonlyArray<{ readonly __typename?: 'NftTrade', readonly amount: number, readonly contractAddress: string, readonly id: string, readonly marketplace: NftMarketplace, readonly tokenId: string, readonly tokenType?: NftStandard, readonly price: { readonly __typename?: 'TokenAmount', readonly id: string, readonly currency: Currency, readonly value: string }, readonly quotePrice?: { readonly __typename?: 'TokenAmount', readonly id: string, readonly currency: Currency, readonly value: string } }>, readonly sendAmount: { readonly __typename?: 'TokenAmount', readonly id: string, readonly currency: Currency, readonly value: string } } };
+
+export type TrendingCollectionsQueryVariables = Exact<{
+  size?: InputMaybe<Scalars['Int']>;
+  timePeriod?: InputMaybe<HistoryDuration>;
+}>;
+
+
+export type TrendingCollectionsQuery = { readonly __typename?: 'Query', readonly topCollections?: { readonly __typename?: 'NftCollectionConnection', readonly edges: ReadonlyArray<{ readonly __typename?: 'NftCollectionEdge', readonly node: { readonly __typename?: 'NftCollection', readonly name?: string, readonly isVerified?: boolean, readonly nftContracts?: ReadonlyArray<{ readonly __typename?: 'NftContract', readonly address: string, readonly totalSupply?: number }>, readonly image?: { readonly __typename?: 'Image', readonly url: string }, readonly bannerImage?: { readonly __typename?: 'Image', readonly url: string }, readonly markets?: ReadonlyArray<{ readonly __typename?: 'NftCollectionMarket', readonly owners?: number, readonly floorPrice?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly totalVolume?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly volume?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly volumePercentChange?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly floorPricePercentChange?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly sales?: { readonly __typename?: 'TimestampedAmount', readonly value: number }, readonly listings?: { readonly __typename?: 'TimestampedAmount', readonly value: number } }> } }> } };
+
+export type PortfolioBalancesQueryVariables = Exact<{
+  ownerAddress: Scalars['String'];
+  chains: ReadonlyArray<Chain> | Chain;
+}>;
+
+
+export type PortfolioBalancesQuery = { readonly __typename?: 'Query', readonly portfolios?: ReadonlyArray<{ readonly __typename?: 'Portfolio', readonly id: string, readonly tokensTotalDenominatedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly tokensTotalDenominatedValueChange?: { readonly __typename?: 'AmountChange', readonly absolute?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly percentage?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number } }, readonly tokenBalances?: ReadonlyArray<{ readonly __typename?: 'TokenBalance', readonly id: string, readonly quantity?: number, readonly denominatedValue?: { readonly __typename?: 'Amount', readonly id: string, readonly currency?: Currency, readonly value: number }, readonly tokenProjectMarket?: { readonly __typename?: 'TokenProjectMarket', readonly id: string, readonly pricePercentChange?: { readonly __typename?: 'Amount', readonly id: string, readonly value: number }, readonly tokenProject: { readonly __typename?: 'TokenProject', readonly id: string, readonly logoUrl?: string, readonly isSpam?: boolean } }, readonly token?: { readonly __typename?: 'Token', readonly id: string, readonly chain: Chain, readonly address?: string, readonly name?: string, readonly symbol?: string, readonly standard?: TokenStandard, readonly decimals?: number } }> }> };
+
+export const TransactionPartsFragmentDoc = gql`
+    fragment TransactionParts on Transaction {
+  id
+  blockNumber
+  hash
+  status
+  to
+  from
+  nonce
+}
+    `;
+export const TokenAssetPartsFragmentDoc = gql`
+    fragment TokenAssetParts on Token {
+  id
+  name
+  symbol
+  address
+  decimals
+  chain
+  standard
+  project {
+    id
+    isSpam
+    logo {
+      id
+      url
+    }
+  }
+}
+    `;
+export const TokenTransferPartsFragmentDoc = gql`
+    fragment TokenTransferParts on TokenTransfer {
+  id
+  asset {
+    ...TokenAssetParts
+  }
+  tokenStandard
+  quantity
+  sender
+  recipient
+  direction
+  transactedValue {
+    id
+    currency
+    value
+  }
+}
+    ${TokenAssetPartsFragmentDoc}`;
+export const NftAssetPartsFragmentDoc = gql`
+    fragment NFTAssetParts on NftAsset {
+  id
+  name
+  nftContract {
+    id
+    chain
+    address
+  }
+  tokenId
+  image {
+    id
+    url
+  }
+  collection {
+    id
+    name
+  }
+}
+    `;
+export const NftTransferPartsFragmentDoc = gql`
+    fragment NFTTransferParts on NftTransfer {
+  id
+  asset {
+    ...NFTAssetParts
+  }
+  nftStandard
+  sender
+  recipient
+  direction
+}
+    ${NftAssetPartsFragmentDoc}`;
+export const TokenApprovalPartsFragmentDoc = gql`
+    fragment TokenApprovalParts on TokenApproval {
+  id
+  asset {
+    ...TokenAssetParts
+  }
+  tokenStandard
+  approvedAddress
+  quantity
+}
+    ${TokenAssetPartsFragmentDoc}`;
+export const NftApprovalPartsFragmentDoc = gql`
+    fragment NFTApprovalParts on NftApproval {
+  id
+  asset {
+    ...NFTAssetParts
+  }
+  nftStandard
+  approvedAddress
+}
+    ${NftAssetPartsFragmentDoc}`;
+export const NftApproveForAllPartsFragmentDoc = gql`
+    fragment NFTApproveForAllParts on NftApproveForAll {
+  id
+  asset {
+    ...NFTAssetParts
+  }
+  nftStandard
+  operatorAddress
+  approved
+}
+    ${NftAssetPartsFragmentDoc}`;
+export const TransactionDetailsPartsFragmentDoc = gql`
+    fragment TransactionDetailsParts on TransactionDetails {
+  id
+  type
+  from
+  to
+  hash
+  nonce
+  status
+  assetChanges {
+    __typename
+    ... on TokenTransfer {
+      ...TokenTransferParts
+    }
+    ... on NftTransfer {
+      ...NFTTransferParts
+    }
+    ... on TokenApproval {
+      ...TokenApprovalParts
+    }
+    ... on NftApproval {
+      ...NFTApprovalParts
+    }
+    ... on NftApproveForAll {
+      ...NFTApproveForAllParts
+    }
+  }
+}
+    ${TokenTransferPartsFragmentDoc}
+${NftTransferPartsFragmentDoc}
+${TokenApprovalPartsFragmentDoc}
+${NftApprovalPartsFragmentDoc}
+${NftApproveForAllPartsFragmentDoc}`;
+export const SwapOrderDetailsPartsFragmentDoc = gql`
+    fragment SwapOrderDetailsParts on SwapOrderDetails {
+  id
+  offerer
+  hash
+  orderStatus: status
+  inputToken {
+    ...TokenAssetParts
+  }
+  inputTokenQuantity
+  outputToken {
+    ...TokenAssetParts
+  }
+  outputTokenQuantity
+}
+    ${TokenAssetPartsFragmentDoc}`;
+export const AssetActivityPartsFragmentDoc = gql`
+    fragment AssetActivityParts on AssetActivity {
+  id
+  timestamp
+  chain
+  details {
+    __typename
+    ... on TransactionDetails {
+      ...TransactionDetailsParts
+    }
+    ... on SwapOrderDetails {
+      ...SwapOrderDetailsParts
+    }
+  }
+}
+    ${TransactionDetailsPartsFragmentDoc}
+${SwapOrderDetailsPartsFragmentDoc}`;
+export const ConvertDocument = gql`
+    query Convert($toCurrency: Currency!) {
+  convert(fromAmount: {currency: USD, value: 1.0}, toCurrency: $toCurrency) {
+    id
+    value
+    currency
+  }
+}
+    `;
+
+/**
+ * __useConvertQuery__
+ *
+ * To run a query within a React component, call `useConvertQuery` and pass it any options that fit your needs.
+ * When your component renders, `useConvertQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useConvertQuery({
+ *   variables: {
+ *      toCurrency: // value for 'toCurrency'
+ *   },
+ * });
+ */
+export function useConvertQuery(baseOptions: Apollo.QueryHookOptions<ConvertQuery, ConvertQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<ConvertQuery, ConvertQueryVariables>(ConvertDocument, options);
+      }
+export function useConvertLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ConvertQuery, ConvertQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<ConvertQuery, ConvertQueryVariables>(ConvertDocument, options);
+        }
+export type ConvertQueryHookResult = ReturnType<typeof useConvertQuery>;
+export type ConvertLazyQueryHookResult = ReturnType<typeof useConvertLazyQuery>;
+export type ConvertQueryResult = Apollo.QueryResult<ConvertQuery, ConvertQueryVariables>;
+export const RecentlySearchedAssetsDocument = gql`
+    query RecentlySearchedAssets($collectionAddresses: [String!]!, $contracts: [ContractInput!]!) {
+  nftCollections(filter: {addresses: $collectionAddresses}) {
+    edges {
+      node {
+        collectionId
+        image {
+          url
+        }
+        isVerified
+        name
+        numAssets
+        nftContracts {
+          address
+        }
+        markets(currencies: ETH) {
+          floorPrice {
+            currency
+            value
+          }
+        }
+      }
+    }
+  }
+  tokens(contracts: $contracts) {
+    id
+    decimals
+    name
+    chain
+    standard
+    address
+    symbol
+    market(currency: USD) {
+      id
+      price {
+        id
+        value
+        currency
+      }
+      pricePercentChange(duration: DAY) {
+        id
+        value
+      }
+      volume24H: volume(duration: DAY) {
+        id
+        value
+        currency
+      }
+    }
+    project {
+      id
+      logoUrl
+      safetyLevel
+    }
+  }
+}
+    `;
+
+/**
+ * __useRecentlySearchedAssetsQuery__
+ *
+ * To run a query within a React component, call `useRecentlySearchedAssetsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useRecentlySearchedAssetsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useRecentlySearchedAssetsQuery({
+ *   variables: {
+ *      collectionAddresses: // value for 'collectionAddresses'
+ *      contracts: // value for 'contracts'
+ *   },
+ * });
+ */
+export function useRecentlySearchedAssetsQuery(baseOptions: Apollo.QueryHookOptions<RecentlySearchedAssetsQuery, RecentlySearchedAssetsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<RecentlySearchedAssetsQuery, RecentlySearchedAssetsQueryVariables>(RecentlySearchedAssetsDocument, options);
+      }
+export function useRecentlySearchedAssetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<RecentlySearchedAssetsQuery, RecentlySearchedAssetsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<RecentlySearchedAssetsQuery, RecentlySearchedAssetsQueryVariables>(RecentlySearchedAssetsDocument, options);
+        }
+export type RecentlySearchedAssetsQueryHookResult = ReturnType<typeof useRecentlySearchedAssetsQuery>;
+export type RecentlySearchedAssetsLazyQueryHookResult = ReturnType<typeof useRecentlySearchedAssetsLazyQuery>;
+export type RecentlySearchedAssetsQueryResult = Apollo.QueryResult<RecentlySearchedAssetsQuery, RecentlySearchedAssetsQueryVariables>;
+export const SearchTokensDocument = gql`
+    query SearchTokens($searchQuery: String!) {
+  searchTokens(searchQuery: $searchQuery) {
+    id
+    decimals
+    name
+    chain
+    standard
+    address
+    symbol
+    market(currency: USD) {
+      id
+      price {
+        id
+        value
+        currency
+      }
+      pricePercentChange(duration: DAY) {
+        id
+        value
+      }
+      volume24H: volume(duration: DAY) {
+        id
+        value
+        currency
+      }
+    }
+    project {
+      id
+      logoUrl
+      safetyLevel
+    }
+  }
+}
+    `;
+
+/**
+ * __useSearchTokensQuery__
+ *
+ * To run a query within a React component, call `useSearchTokensQuery` and pass it any options that fit your needs.
+ * When your component renders, `useSearchTokensQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useSearchTokensQuery({
+ *   variables: {
+ *      searchQuery: // value for 'searchQuery'
+ *   },
+ * });
+ */
+export function useSearchTokensQuery(baseOptions: Apollo.QueryHookOptions<SearchTokensQuery, SearchTokensQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<SearchTokensQuery, SearchTokensQueryVariables>(SearchTokensDocument, options);
+      }
+export function useSearchTokensLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<SearchTokensQuery, SearchTokensQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<SearchTokensQuery, SearchTokensQueryVariables>(SearchTokensDocument, options);
+        }
+export type SearchTokensQueryHookResult = ReturnType<typeof useSearchTokensQuery>;
+export type SearchTokensLazyQueryHookResult = ReturnType<typeof useSearchTokensLazyQuery>;
+export type SearchTokensQueryResult = Apollo.QueryResult<SearchTokensQuery, SearchTokensQueryVariables>;
+export const TokenDocument = gql`
+    query Token($chain: Chain!, $address: String = null) {
+  token(chain: $chain, address: $address) {
+    id
+    decimals
+    name
+    chain
+    address
+    symbol
+    standard
+    market(currency: USD) {
+      id
+      totalValueLocked {
+        id
+        value
+        currency
+      }
+      price {
+        id
+        value
+        currency
+      }
+      volume24H: volume(duration: DAY) {
+        id
+        value
+        currency
+      }
+      priceHigh52W: priceHighLow(duration: YEAR, highLow: HIGH) {
+        id
+        value
+      }
+      priceLow52W: priceHighLow(duration: YEAR, highLow: LOW) {
+        id
+        value
+      }
+    }
+    project {
+      id
+      description
+      homepageUrl
+      twitterName
+      logoUrl
+      tokens {
+        id
+        chain
+        address
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTokenQuery__
+ *
+ * To run a query within a React component, call `useTokenQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTokenQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useTokenQuery(baseOptions: Apollo.QueryHookOptions<TokenQuery, TokenQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TokenQuery, TokenQueryVariables>(TokenDocument, options);
+      }
+export function useTokenLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TokenQuery, TokenQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TokenQuery, TokenQueryVariables>(TokenDocument, options);
+        }
+export type TokenQueryHookResult = ReturnType<typeof useTokenQuery>;
+export type TokenLazyQueryHookResult = ReturnType<typeof useTokenLazyQuery>;
+export type TokenQueryResult = Apollo.QueryResult<TokenQuery, TokenQueryVariables>;
+export const TokenProjectDocument = gql`
+    query TokenProject($chain: Chain!, $address: String = null) {
+  token(chain: $chain, address: $address) {
+    id
+    decimals
+    name
+    chain
+    address
+    symbol
+    standard
+    project {
+      id
+      description
+      homepageUrl
+      twitterName
+      logoUrl
+      tokens {
+        id
+        chain
+        address
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTokenProjectQuery__
+ *
+ * To run a query within a React component, call `useTokenProjectQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenProjectQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTokenProjectQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useTokenProjectQuery(baseOptions: Apollo.QueryHookOptions<TokenProjectQuery, TokenProjectQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TokenProjectQuery, TokenProjectQueryVariables>(TokenProjectDocument, options);
+      }
+export function useTokenProjectLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TokenProjectQuery, TokenProjectQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TokenProjectQuery, TokenProjectQueryVariables>(TokenProjectDocument, options);
+        }
+export type TokenProjectQueryHookResult = ReturnType<typeof useTokenProjectQuery>;
+export type TokenProjectLazyQueryHookResult = ReturnType<typeof useTokenProjectLazyQuery>;
+export type TokenProjectQueryResult = Apollo.QueryResult<TokenProjectQuery, TokenProjectQueryVariables>;
+export const TokenPriceDocument = gql`
+    query TokenPrice($chain: Chain!, $address: String = null, $duration: HistoryDuration!) {
+  token(chain: $chain, address: $address) {
+    id
+    address
+    chain
+    market(currency: USD) {
+      id
+      price {
+        id
+        value
+      }
+      priceHistory(duration: $duration) {
+        id
+        timestamp
+        value
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTokenPriceQuery__
+ *
+ * To run a query within a React component, call `useTokenPriceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenPriceQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTokenPriceQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *      address: // value for 'address'
+ *      duration: // value for 'duration'
+ *   },
+ * });
+ */
+export function useTokenPriceQuery(baseOptions: Apollo.QueryHookOptions<TokenPriceQuery, TokenPriceQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TokenPriceQuery, TokenPriceQueryVariables>(TokenPriceDocument, options);
+      }
+export function useTokenPriceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TokenPriceQuery, TokenPriceQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TokenPriceQuery, TokenPriceQueryVariables>(TokenPriceDocument, options);
+        }
+export type TokenPriceQueryHookResult = ReturnType<typeof useTokenPriceQuery>;
+export type TokenPriceLazyQueryHookResult = ReturnType<typeof useTokenPriceLazyQuery>;
+export type TokenPriceQueryResult = Apollo.QueryResult<TokenPriceQuery, TokenPriceQueryVariables>;
+export const UniswapPricesDocument = gql`
+    query UniswapPrices($contracts: [ContractInput!]!) {
+  tokens(contracts: $contracts) {
+    id
+    address
+    chain
+    standard
+    project {
+      id
+      markets(currencies: [USD]) {
+        id
+        price {
+          id
+          value
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useUniswapPricesQuery__
+ *
+ * To run a query within a React component, call `useUniswapPricesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useUniswapPricesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useUniswapPricesQuery({
+ *   variables: {
+ *      contracts: // value for 'contracts'
+ *   },
+ * });
+ */
+export function useUniswapPricesQuery(baseOptions: Apollo.QueryHookOptions<UniswapPricesQuery, UniswapPricesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<UniswapPricesQuery, UniswapPricesQueryVariables>(UniswapPricesDocument, options);
+      }
+export function useUniswapPricesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<UniswapPricesQuery, UniswapPricesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<UniswapPricesQuery, UniswapPricesQueryVariables>(UniswapPricesDocument, options);
+        }
+export type UniswapPricesQueryHookResult = ReturnType<typeof useUniswapPricesQuery>;
+export type UniswapPricesLazyQueryHookResult = ReturnType<typeof useUniswapPricesLazyQuery>;
+export type UniswapPricesQueryResult = Apollo.QueryResult<UniswapPricesQuery, UniswapPricesQueryVariables>;
+export const TokenSpotPriceDocument = gql`
+    query TokenSpotPrice($chain: Chain!, $address: String = null) {
+  token(chain: $chain, address: $address) {
+    id
+    address
+    chain
+    name
+    symbol
+    project {
+      id
+      markets(currencies: [USD]) {
+        id
+        price {
+          id
+          value
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTokenSpotPriceQuery__
+ *
+ * To run a query within a React component, call `useTokenSpotPriceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTokenSpotPriceQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTokenSpotPriceQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useTokenSpotPriceQuery(baseOptions: Apollo.QueryHookOptions<TokenSpotPriceQuery, TokenSpotPriceQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TokenSpotPriceQuery, TokenSpotPriceQueryVariables>(TokenSpotPriceDocument, options);
+      }
+export function useTokenSpotPriceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TokenSpotPriceQuery, TokenSpotPriceQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TokenSpotPriceQuery, TokenSpotPriceQueryVariables>(TokenSpotPriceDocument, options);
+        }
+export type TokenSpotPriceQueryHookResult = ReturnType<typeof useTokenSpotPriceQuery>;
+export type TokenSpotPriceLazyQueryHookResult = ReturnType<typeof useTokenSpotPriceLazyQuery>;
+export type TokenSpotPriceQueryResult = Apollo.QueryResult<TokenSpotPriceQuery, TokenSpotPriceQueryVariables>;
+export const TopTokens100Document = gql`
+    query TopTokens100($duration: HistoryDuration!, $chain: Chain!) {
+  topTokens(pageSize: 100, page: 1, chain: $chain, orderBy: VOLUME) {
+    id
+    name
+    chain
+    address
+    symbol
+    standard
+    market(currency: USD) {
+      id
+      totalValueLocked {
+        id
+        value
+        currency
+      }
+      price {
+        id
+        value
+        currency
+      }
+      pricePercentChange(duration: $duration) {
+        id
+        currency
+        value
+      }
+      volume(duration: $duration) {
+        id
+        value
+        currency
+      }
+    }
+    project {
+      id
+      logoUrl
+    }
+  }
+}
+    `;
+
+/**
+ * __useTopTokens100Query__
+ *
+ * To run a query within a React component, call `useTopTokens100Query` and pass it any options that fit your needs.
+ * When your component renders, `useTopTokens100Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTopTokens100Query({
+ *   variables: {
+ *      duration: // value for 'duration'
+ *      chain: // value for 'chain'
+ *   },
+ * });
+ */
+export function useTopTokens100Query(baseOptions: Apollo.QueryHookOptions<TopTokens100Query, TopTokens100QueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TopTokens100Query, TopTokens100QueryVariables>(TopTokens100Document, options);
+      }
+export function useTopTokens100LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TopTokens100Query, TopTokens100QueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TopTokens100Query, TopTokens100QueryVariables>(TopTokens100Document, options);
+        }
+export type TopTokens100QueryHookResult = ReturnType<typeof useTopTokens100Query>;
+export type TopTokens100LazyQueryHookResult = ReturnType<typeof useTopTokens100LazyQuery>;
+export type TopTokens100QueryResult = Apollo.QueryResult<TopTokens100Query, TopTokens100QueryVariables>;
+export const TopTokensSparklineDocument = gql`
+    query TopTokensSparkline($duration: HistoryDuration!, $chain: Chain!) {
+  topTokens(pageSize: 100, page: 1, chain: $chain, orderBy: VOLUME) {
+    id
+    address
+    chain
+    market(currency: USD) {
+      id
+      priceHistory(duration: $duration) {
+        id
+        timestamp
+        value
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTopTokensSparklineQuery__
+ *
+ * To run a query within a React component, call `useTopTokensSparklineQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTopTokensSparklineQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTopTokensSparklineQuery({
+ *   variables: {
+ *      duration: // value for 'duration'
+ *      chain: // value for 'chain'
+ *   },
+ * });
+ */
+export function useTopTokensSparklineQuery(baseOptions: Apollo.QueryHookOptions<TopTokensSparklineQuery, TopTokensSparklineQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TopTokensSparklineQuery, TopTokensSparklineQueryVariables>(TopTokensSparklineDocument, options);
+      }
+export function useTopTokensSparklineLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TopTokensSparklineQuery, TopTokensSparklineQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TopTokensSparklineQuery, TopTokensSparklineQueryVariables>(TopTokensSparklineDocument, options);
+        }
+export type TopTokensSparklineQueryHookResult = ReturnType<typeof useTopTokensSparklineQuery>;
+export type TopTokensSparklineLazyQueryHookResult = ReturnType<typeof useTopTokensSparklineLazyQuery>;
+export type TopTokensSparklineQueryResult = Apollo.QueryResult<TopTokensSparklineQuery, TopTokensSparklineQueryVariables>;
+export const TrendingTokensDocument = gql`
+    query TrendingTokens($chain: Chain!) {
+  topTokens(pageSize: 4, page: 1, chain: $chain, orderBy: VOLUME) {
+    id
+    decimals
+    name
+    chain
+    standard
+    address
+    symbol
+    market(currency: USD) {
+      id
+      price {
+        id
+        value
+        currency
+      }
+      pricePercentChange(duration: DAY) {
+        id
+        value
+      }
+      volume24H: volume(duration: DAY) {
+        id
+        value
+        currency
+      }
+    }
+    project {
+      id
+      logoUrl
+      safetyLevel
+    }
+  }
+}
+    `;
+
+/**
+ * __useTrendingTokensQuery__
+ *
+ * To run a query within a React component, call `useTrendingTokensQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTrendingTokensQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTrendingTokensQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *   },
+ * });
+ */
+export function useTrendingTokensQuery(baseOptions: Apollo.QueryHookOptions<TrendingTokensQuery, TrendingTokensQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TrendingTokensQuery, TrendingTokensQueryVariables>(TrendingTokensDocument, options);
+      }
+export function useTrendingTokensLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TrendingTokensQuery, TrendingTokensQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TrendingTokensQuery, TrendingTokensQueryVariables>(TrendingTokensDocument, options);
+        }
+export type TrendingTokensQueryHookResult = ReturnType<typeof useTrendingTokensQuery>;
+export type TrendingTokensLazyQueryHookResult = ReturnType<typeof useTrendingTokensLazyQuery>;
+export type TrendingTokensQueryResult = Apollo.QueryResult<TrendingTokensQuery, TrendingTokensQueryVariables>;
+export const ActivityDocument = gql`
+    query Activity($account: String!) {
+  portfolios(ownerAddresses: [$account]) {
+    id
+    assetActivities(pageSize: 100, page: 1, includeOffChain: true) {
+      ...AssetActivityParts
+    }
+  }
+}
+    ${AssetActivityPartsFragmentDoc}`;
+
+/**
+ * __useActivityQuery__
+ *
+ * To run a query within a React component, call `useActivityQuery` and pass it any options that fit your needs.
+ * When your component renders, `useActivityQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useActivityQuery({
+ *   variables: {
+ *      account: // value for 'account'
+ *   },
+ * });
+ */
+export function useActivityQuery(baseOptions: Apollo.QueryHookOptions<ActivityQuery, ActivityQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<ActivityQuery, ActivityQueryVariables>(ActivityDocument, options);
+      }
+export function useActivityLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<ActivityQuery, ActivityQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<ActivityQuery, ActivityQueryVariables>(ActivityDocument, options);
+        }
+export type ActivityQueryHookResult = ReturnType<typeof useActivityQuery>;
+export type ActivityLazyQueryHookResult = ReturnType<typeof useActivityLazyQuery>;
+export type ActivityQueryResult = Apollo.QueryResult<ActivityQuery, ActivityQueryVariables>;
+export const AssetDocument = gql`
+    query Asset($address: String!, $orderBy: NftAssetSortableField, $asc: Boolean, $filter: NftAssetsFilterInput, $first: Int, $after: String, $last: Int, $before: String) {
+  nftAssets(
+    address: $address
+    orderBy: $orderBy
+    asc: $asc
+    filter: $filter
+    first: $first
+    after: $after
+    last: $last
+    before: $before
+  ) {
+    edges {
+      node {
+        id
+        name
+        image {
+          url
+        }
+        smallImage {
+          url
+        }
+        tokenId
+        animationUrl
+        suspiciousFlag
+        collection {
+          name
+          isVerified
+          nftContracts {
+            address
+            standard
+          }
+        }
+        listings(first: 1) {
+          edges {
+            node {
+              address
+              createdAt
+              endAt
+              id
+              maker
+              marketplace
+              marketplaceUrl
+              orderHash
+              price {
+                currency
+                value
+              }
+              quantity
+              startAt
+              status
+              taker
+              tokenId
+              type
+              protocolParameters
+            }
+            cursor
+          }
+        }
+        rarities {
+          rank
+        }
+      }
+      cursor
+    }
+    totalCount
+    pageInfo {
+      endCursor
+      hasNextPage
+      hasPreviousPage
+      startCursor
+    }
+  }
+}
+    `;
+
+/**
+ * __useAssetQuery__
+ *
+ * To run a query within a React component, call `useAssetQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAssetQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useAssetQuery({
+ *   variables: {
+ *      address: // value for 'address'
+ *      orderBy: // value for 'orderBy'
+ *      asc: // value for 'asc'
+ *      filter: // value for 'filter'
+ *      first: // value for 'first'
+ *      after: // value for 'after'
+ *      last: // value for 'last'
+ *      before: // value for 'before'
+ *   },
+ * });
+ */
+export function useAssetQuery(baseOptions: Apollo.QueryHookOptions<AssetQuery, AssetQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<AssetQuery, AssetQueryVariables>(AssetDocument, options);
+      }
+export function useAssetLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AssetQuery, AssetQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<AssetQuery, AssetQueryVariables>(AssetDocument, options);
+        }
+export type AssetQueryHookResult = ReturnType<typeof useAssetQuery>;
+export type AssetLazyQueryHookResult = ReturnType<typeof useAssetLazyQuery>;
+export type AssetQueryResult = Apollo.QueryResult<AssetQuery, AssetQueryVariables>;
+export const CollectionDocument = gql`
+    query Collection($addresses: [String!]!) {
+  nftCollections(filter: {addresses: $addresses}) {
+    edges {
+      cursor
+      node {
+        bannerImage {
+          url
+        }
+        collectionId
+        description
+        discordUrl
+        homepageUrl
+        image {
+          url
+        }
+        instagramName
+        isVerified
+        name
+        numAssets
+        twitterName
+        nftContracts {
+          address
+          chain
+          name
+          standard
+          symbol
+          totalSupply
+        }
+        traits {
+          name
+          values
+          stats {
+            name
+            value
+            assets
+            listings
+          }
+        }
+        markets(currencies: ETH) {
+          floorPrice {
+            currency
+            value
+          }
+          owners
+          totalVolume {
+            value
+            currency
+          }
+          listings {
+            value
+          }
+          volume(duration: DAY) {
+            value
+            currency
+          }
+          volumePercentChange(duration: DAY) {
+            value
+            currency
+          }
+          floorPricePercentChange(duration: DAY) {
+            value
+            currency
+          }
+          marketplaces {
+            marketplace
+            listings
+            floorPrice
+          }
+        }
+      }
+    }
+    pageInfo {
+      endCursor
+      hasNextPage
+      hasPreviousPage
+      startCursor
+    }
+  }
+}
+    `;
+
+/**
+ * __useCollectionQuery__
+ *
+ * To run a query within a React component, call `useCollectionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCollectionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCollectionQuery({
+ *   variables: {
+ *      addresses: // value for 'addresses'
+ *   },
+ * });
+ */
+export function useCollectionQuery(baseOptions: Apollo.QueryHookOptions<CollectionQuery, CollectionQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<CollectionQuery, CollectionQueryVariables>(CollectionDocument, options);
+      }
+export function useCollectionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CollectionQuery, CollectionQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<CollectionQuery, CollectionQueryVariables>(CollectionDocument, options);
+        }
+export type CollectionQueryHookResult = ReturnType<typeof useCollectionQuery>;
+export type CollectionLazyQueryHookResult = ReturnType<typeof useCollectionLazyQuery>;
+export type CollectionQueryResult = Apollo.QueryResult<CollectionQuery, CollectionQueryVariables>;
+export const CollectionSearchDocument = gql`
+    query CollectionSearch($query: String!) {
+  nftCollections(filter: {nameQuery: $query}) {
+    edges {
+      cursor
+      node {
+        image {
+          url
+        }
+        isVerified
+        name
+        numAssets
+        nftContracts {
+          address
+          chain
+          name
+          symbol
+          totalSupply
+        }
+        markets(currencies: ETH) {
+          floorPrice {
+            currency
+            value
+          }
+        }
+      }
+    }
+    pageInfo {
+      endCursor
+      hasNextPage
+      hasPreviousPage
+      startCursor
+    }
+  }
+}
+    `;
+
+/**
+ * __useCollectionSearchQuery__
+ *
+ * To run a query within a React component, call `useCollectionSearchQuery` and pass it any options that fit your needs.
+ * When your component renders, `useCollectionSearchQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useCollectionSearchQuery({
+ *   variables: {
+ *      query: // value for 'query'
+ *   },
+ * });
+ */
+export function useCollectionSearchQuery(baseOptions: Apollo.QueryHookOptions<CollectionSearchQuery, CollectionSearchQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<CollectionSearchQuery, CollectionSearchQueryVariables>(CollectionSearchDocument, options);
+      }
+export function useCollectionSearchLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<CollectionSearchQuery, CollectionSearchQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<CollectionSearchQuery, CollectionSearchQueryVariables>(CollectionSearchDocument, options);
+        }
+export type CollectionSearchQueryHookResult = ReturnType<typeof useCollectionSearchQuery>;
+export type CollectionSearchLazyQueryHookResult = ReturnType<typeof useCollectionSearchLazyQuery>;
+export type CollectionSearchQueryResult = Apollo.QueryResult<CollectionSearchQuery, CollectionSearchQueryVariables>;
+export const DetailsDocument = gql`
+    query Details($address: String!, $tokenId: String!) {
+  nftAssets(address: $address, filter: {listed: false, tokenIds: [$tokenId]}) {
+    edges {
+      node {
+        id
+        name
+        ownerAddress
+        image {
+          url
+        }
+        smallImage {
+          url
+        }
+        originalImage {
+          url
+        }
+        tokenId
+        description
+        animationUrl
+        suspiciousFlag
+        creator {
+          address
+          profileImage {
+            url
+          }
+          isVerified
+        }
+        collection {
+          name
+          isVerified
+          numAssets
+          twitterName
+          discordUrl
+          homepageUrl
+          image {
+            url
+          }
+          nftContracts {
+            address
+            standard
+          }
+          description
+        }
+        listings(first: 1) {
+          edges {
+            node {
+              address
+              createdAt
+              endAt
+              id
+              maker
+              marketplace
+              marketplaceUrl
+              orderHash
+              price {
+                currency
+                value
+              }
+              quantity
+              startAt
+              status
+              taker
+              tokenId
+              type
+              protocolParameters
+            }
+            cursor
+          }
+        }
+        rarities {
+          provider
+          rank
+          score
+        }
+        metadataUrl
+        traits {
+          name
+          value
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useDetailsQuery__
+ *
+ * To run a query within a React component, call `useDetailsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useDetailsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useDetailsQuery({
+ *   variables: {
+ *      address: // value for 'address'
+ *      tokenId: // value for 'tokenId'
+ *   },
+ * });
+ */
+export function useDetailsQuery(baseOptions: Apollo.QueryHookOptions<DetailsQuery, DetailsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<DetailsQuery, DetailsQueryVariables>(DetailsDocument, options);
+      }
+export function useDetailsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<DetailsQuery, DetailsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<DetailsQuery, DetailsQueryVariables>(DetailsDocument, options);
+        }
+export type DetailsQueryHookResult = ReturnType<typeof useDetailsQuery>;
+export type DetailsLazyQueryHookResult = ReturnType<typeof useDetailsLazyQuery>;
+export type DetailsQueryResult = Apollo.QueryResult<DetailsQuery, DetailsQueryVariables>;
+export const NftActivityDocument = gql`
+    query NftActivity($filter: NftActivityFilterInput, $after: String, $first: Int) {
+  nftActivity(filter: $filter, after: $after, first: $first) {
+    edges {
+      node {
+        id
+        address
+        tokenId
+        asset {
+          id
+          metadataUrl
+          image {
+            id
+            url
+          }
+          smallImage {
+            id
+            url
+          }
+          name
+          rarities {
+            id
+            provider
+            rank
+            score
+          }
+          suspiciousFlag
+          nftContract {
+            id
+            standard
+          }
+          collection {
+            id
+            image {
+              id
+              url
+            }
+          }
+        }
+        type
+        marketplace
+        fromAddress
+        toAddress
+        transactionHash
+        price {
+          id
+          value
+        }
+        orderStatus
+        quantity
+        url
+        timestamp
+      }
+    }
+    pageInfo {
+      endCursor
+      hasNextPage
+      hasPreviousPage
+      startCursor
+    }
+  }
+}
+    `;
+
+/**
+ * __useNftActivityQuery__
+ *
+ * To run a query within a React component, call `useNftActivityQuery` and pass it any options that fit your needs.
+ * When your component renders, `useNftActivityQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useNftActivityQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      after: // value for 'after'
+ *      first: // value for 'first'
+ *   },
+ * });
+ */
+export function useNftActivityQuery(baseOptions?: Apollo.QueryHookOptions<NftActivityQuery, NftActivityQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<NftActivityQuery, NftActivityQueryVariables>(NftActivityDocument, options);
+      }
+export function useNftActivityLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NftActivityQuery, NftActivityQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<NftActivityQuery, NftActivityQueryVariables>(NftActivityDocument, options);
+        }
+export type NftActivityQueryHookResult = ReturnType<typeof useNftActivityQuery>;
+export type NftActivityLazyQueryHookResult = ReturnType<typeof useNftActivityLazyQuery>;
+export type NftActivityQueryResult = Apollo.QueryResult<NftActivityQuery, NftActivityQueryVariables>;
+export const NftBalanceDocument = gql`
+    query NftBalance($ownerAddress: String!, $filter: NftBalancesFilterInput, $first: Int, $after: String, $last: Int, $before: String) {
+  nftBalances(
+    ownerAddress: $ownerAddress
+    filter: $filter
+    first: $first
+    after: $after
+    last: $last
+    before: $before
+  ) {
+    edges {
+      node {
+        ownedAsset {
+          id
+          animationUrl
+          collection {
+            id
+            isVerified
+            image {
+              id
+              url
+            }
+            name
+            twitterName
+            nftContracts {
+              id
+              address
+              chain
+              name
+              standard
+              symbol
+              totalSupply
+            }
+            markets(currencies: ETH) {
+              id
+              floorPrice {
+                id
+                value
+              }
+            }
+          }
+          description
+          flaggedBy
+          image {
+            id
+            url
+          }
+          originalImage {
+            id
+            url
+          }
+          name
+          ownerAddress
+          smallImage {
+            id
+            url
+          }
+          suspiciousFlag
+          tokenId
+          thumbnail {
+            id
+            url
+          }
+          listings(first: 1) {
+            edges {
+              node {
+                price {
+                  id
+                  value
+                  currency
+                }
+                createdAt
+                marketplace
+                endAt
+              }
+            }
+          }
+        }
+        listedMarketplaces
+        listingFees {
+          id
+          payoutAddress
+          basisPoints
+        }
+        lastPrice {
+          id
+          currency
+          timestamp
+          value
+        }
+      }
+    }
+    pageInfo {
+      endCursor
+      hasNextPage
+      hasPreviousPage
+      startCursor
+    }
+  }
+}
+    `;
+
+/**
+ * __useNftBalanceQuery__
+ *
+ * To run a query within a React component, call `useNftBalanceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useNftBalanceQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useNftBalanceQuery({
+ *   variables: {
+ *      ownerAddress: // value for 'ownerAddress'
+ *      filter: // value for 'filter'
+ *      first: // value for 'first'
+ *      after: // value for 'after'
+ *      last: // value for 'last'
+ *      before: // value for 'before'
+ *   },
+ * });
+ */
+export function useNftBalanceQuery(baseOptions: Apollo.QueryHookOptions<NftBalanceQuery, NftBalanceQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<NftBalanceQuery, NftBalanceQueryVariables>(NftBalanceDocument, options);
+      }
+export function useNftBalanceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NftBalanceQuery, NftBalanceQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<NftBalanceQuery, NftBalanceQueryVariables>(NftBalanceDocument, options);
+        }
+export type NftBalanceQueryHookResult = ReturnType<typeof useNftBalanceQuery>;
+export type NftBalanceLazyQueryHookResult = ReturnType<typeof useNftBalanceLazyQuery>;
+export type NftBalanceQueryResult = Apollo.QueryResult<NftBalanceQuery, NftBalanceQueryVariables>;
+export const NftUniversalRouterAddressDocument = gql`
+    query NftUniversalRouterAddress($chain: Chain = ETHEREUM) {
+  nftRoute(chain: $chain, senderAddress: "", nftTrades: []) {
+    toAddress
+  }
+}
+    `;
+
+/**
+ * __useNftUniversalRouterAddressQuery__
+ *
+ * To run a query within a React component, call `useNftUniversalRouterAddressQuery` and pass it any options that fit your needs.
+ * When your component renders, `useNftUniversalRouterAddressQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useNftUniversalRouterAddressQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *   },
+ * });
+ */
+export function useNftUniversalRouterAddressQuery(baseOptions?: Apollo.QueryHookOptions<NftUniversalRouterAddressQuery, NftUniversalRouterAddressQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<NftUniversalRouterAddressQuery, NftUniversalRouterAddressQueryVariables>(NftUniversalRouterAddressDocument, options);
+      }
+export function useNftUniversalRouterAddressLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NftUniversalRouterAddressQuery, NftUniversalRouterAddressQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<NftUniversalRouterAddressQuery, NftUniversalRouterAddressQueryVariables>(NftUniversalRouterAddressDocument, options);
+        }
+export type NftUniversalRouterAddressQueryHookResult = ReturnType<typeof useNftUniversalRouterAddressQuery>;
+export type NftUniversalRouterAddressLazyQueryHookResult = ReturnType<typeof useNftUniversalRouterAddressLazyQuery>;
+export type NftUniversalRouterAddressQueryResult = Apollo.QueryResult<NftUniversalRouterAddressQuery, NftUniversalRouterAddressQueryVariables>;
+export const NftRouteDocument = gql`
+    query NftRoute($chain: Chain = ETHEREUM, $senderAddress: String!, $nftTrades: [NftTradeInput!]!, $tokenTrades: [TokenTradeInput!]) {
+  nftRoute(
+    chain: $chain
+    senderAddress: $senderAddress
+    nftTrades: $nftTrades
+    tokenTrades: $tokenTrades
+  ) {
+    id
+    calldata
+    route {
+      amount
+      contractAddress
+      id
+      marketplace
+      price {
+        id
+        currency
+        value
+      }
+      quotePrice {
+        id
+        currency
+        value
+      }
+      tokenId
+      tokenType
+    }
+    sendAmount {
+      id
+      currency
+      value
+    }
+    toAddress
+  }
+}
+    `;
+
+/**
+ * __useNftRouteQuery__
+ *
+ * To run a query within a React component, call `useNftRouteQuery` and pass it any options that fit your needs.
+ * When your component renders, `useNftRouteQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useNftRouteQuery({
+ *   variables: {
+ *      chain: // value for 'chain'
+ *      senderAddress: // value for 'senderAddress'
+ *      nftTrades: // value for 'nftTrades'
+ *      tokenTrades: // value for 'tokenTrades'
+ *   },
+ * });
+ */
+export function useNftRouteQuery(baseOptions: Apollo.QueryHookOptions<NftRouteQuery, NftRouteQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<NftRouteQuery, NftRouteQueryVariables>(NftRouteDocument, options);
+      }
+export function useNftRouteLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<NftRouteQuery, NftRouteQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<NftRouteQuery, NftRouteQueryVariables>(NftRouteDocument, options);
+        }
+export type NftRouteQueryHookResult = ReturnType<typeof useNftRouteQuery>;
+export type NftRouteLazyQueryHookResult = ReturnType<typeof useNftRouteLazyQuery>;
+export type NftRouteQueryResult = Apollo.QueryResult<NftRouteQuery, NftRouteQueryVariables>;
+export const TrendingCollectionsDocument = gql`
+    query TrendingCollections($size: Int, $timePeriod: HistoryDuration) {
+  topCollections(first: $size, duration: $timePeriod) {
+    edges {
+      node {
+        name
+        nftContracts {
+          address
+          totalSupply
+        }
+        image {
+          url
+        }
+        bannerImage {
+          url
+        }
+        isVerified
+        markets(currencies: ETH) {
+          floorPrice {
+            value
+          }
+          owners
+          totalVolume {
+            value
+          }
+          volume(duration: $timePeriod) {
+            value
+          }
+          volumePercentChange(duration: $timePeriod) {
+            value
+          }
+          floorPricePercentChange(duration: $timePeriod) {
+            value
+          }
+          sales {
+            value
+          }
+          listings {
+            value
+          }
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useTrendingCollectionsQuery__
+ *
+ * To run a query within a React component, call `useTrendingCollectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useTrendingCollectionsQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useTrendingCollectionsQuery({
+ *   variables: {
+ *      size: // value for 'size'
+ *      timePeriod: // value for 'timePeriod'
+ *   },
+ * });
+ */
+export function useTrendingCollectionsQuery(baseOptions?: Apollo.QueryHookOptions<TrendingCollectionsQuery, TrendingCollectionsQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<TrendingCollectionsQuery, TrendingCollectionsQueryVariables>(TrendingCollectionsDocument, options);
+      }
+export function useTrendingCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<TrendingCollectionsQuery, TrendingCollectionsQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<TrendingCollectionsQuery, TrendingCollectionsQueryVariables>(TrendingCollectionsDocument, options);
+        }
+export type TrendingCollectionsQueryHookResult = ReturnType<typeof useTrendingCollectionsQuery>;
+export type TrendingCollectionsLazyQueryHookResult = ReturnType<typeof useTrendingCollectionsLazyQuery>;
+export type TrendingCollectionsQueryResult = Apollo.QueryResult<TrendingCollectionsQuery, TrendingCollectionsQueryVariables>;
+export const PortfolioBalancesDocument = gql`
+    query PortfolioBalances($ownerAddress: String!, $chains: [Chain!]!) {
+  portfolios(ownerAddresses: [$ownerAddress], chains: $chains) {
+    id
+    tokensTotalDenominatedValue {
+      id
+      value
+    }
+    tokensTotalDenominatedValueChange(duration: DAY) {
+      absolute {
+        id
+        value
+      }
+      percentage {
+        id
+        value
+      }
+    }
+    tokenBalances {
+      id
+      quantity
+      denominatedValue {
+        id
+        currency
+        value
+      }
+      tokenProjectMarket {
+        id
+        pricePercentChange(duration: DAY) {
+          id
+          value
+        }
+        tokenProject {
+          id
+          logoUrl
+          isSpam
+        }
+      }
+      token {
+        id
+        chain
+        address
+        name
+        symbol
+        standard
+        decimals
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __usePortfolioBalancesQuery__
+ *
+ * To run a query within a React component, call `usePortfolioBalancesQuery` and pass it any options that fit your needs.
+ * When your component renders, `usePortfolioBalancesQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = usePortfolioBalancesQuery({
+ *   variables: {
+ *      ownerAddress: // value for 'ownerAddress'
+ *      chains: // value for 'chains'
+ *   },
+ * });
+ */
+export function usePortfolioBalancesQuery(baseOptions: Apollo.QueryHookOptions<PortfolioBalancesQuery, PortfolioBalancesQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<PortfolioBalancesQuery, PortfolioBalancesQueryVariables>(PortfolioBalancesDocument, options);
+      }
+export function usePortfolioBalancesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PortfolioBalancesQuery, PortfolioBalancesQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<PortfolioBalancesQuery, PortfolioBalancesQueryVariables>(PortfolioBalancesDocument, options);
+        }
+export type PortfolioBalancesQueryHookResult = ReturnType<typeof usePortfolioBalancesQuery>;
+export type PortfolioBalancesLazyQueryHookResult = ReturnType<typeof usePortfolioBalancesLazyQuery>;
+export type PortfolioBalancesQueryResult = Apollo.QueryResult<PortfolioBalancesQuery, PortfolioBalancesQueryVariables>;
\ No newline at end of file
diff --git a/src/graphql/thegraph/__generated__/types-and-hooks.ts b/src/graphql/thegraph/__generated__/types-and-hooks.ts
new file mode 100644
index 00000000000..bb3ed0b6a88
--- /dev/null
+++ b/src/graphql/thegraph/__generated__/types-and-hooks.ts
@@ -0,0 +1,5554 @@
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T;
+export type InputMaybe<T> = 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]> };
+const defaultOptions = {} as const;
+/** 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;
+  /** 8 bytes signed integer */
+  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 Bundle = {
+  __typename?: 'Bundle';
+  ethPriceUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+};
+
+export type Bundle_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Bundle_Filter>>>;
+  ethPriceUSD?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  ethPriceUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  ethPriceUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  or?: InputMaybe<Array<InputMaybe<Bundle_Filter>>>;
+};
+
+export enum Bundle_OrderBy {
+  EthPriceUsd = 'ethPriceUSD',
+  Id = 'id'
+}
+
+export type Burn = {
+  __typename?: 'Burn';
+  amount: Scalars['BigInt'];
+  amount0: Scalars['BigDecimal'];
+  amount1: Scalars['BigDecimal'];
+  amountUSD?: Maybe<Scalars['BigDecimal']>;
+  id: Scalars['ID'];
+  logIndex?: Maybe<Scalars['BigInt']>;
+  origin: Scalars['Bytes'];
+  owner?: Maybe<Scalars['Bytes']>;
+  pool: Pool;
+  tickLower: Scalars['BigInt'];
+  tickUpper: Scalars['BigInt'];
+  timestamp: Scalars['BigInt'];
+  token0: Token;
+  token1: Token;
+  transaction: Transaction;
+};
+
+export type Burn_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  amount?: InputMaybe<Scalars['BigInt']>;
+  amount0?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount_gt?: InputMaybe<Scalars['BigInt']>;
+  amount_gte?: InputMaybe<Scalars['BigInt']>;
+  amount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  amount_lt?: InputMaybe<Scalars['BigInt']>;
+  amount_lte?: InputMaybe<Scalars['BigInt']>;
+  amount_not?: InputMaybe<Scalars['BigInt']>;
+  amount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  and?: InputMaybe<Array<InputMaybe<Burn_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  logIndex?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  logIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Burn_Filter>>>;
+  origin?: InputMaybe<Scalars['Bytes']>;
+  origin_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_gt?: InputMaybe<Scalars['Bytes']>;
+  origin_gte?: InputMaybe<Scalars['Bytes']>;
+  origin_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  origin_lt?: InputMaybe<Scalars['Bytes']>;
+  origin_lte?: InputMaybe<Scalars['Bytes']>;
+  origin_not?: InputMaybe<Scalars['Bytes']>;
+  origin_not_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner?: InputMaybe<Scalars['Bytes']>;
+  owner_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_gt?: InputMaybe<Scalars['Bytes']>;
+  owner_gte?: InputMaybe<Scalars['Bytes']>;
+  owner_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner_lt?: InputMaybe<Scalars['Bytes']>;
+  owner_lte?: InputMaybe<Scalars['Bytes']>;
+  owner_not?: InputMaybe<Scalars['Bytes']>;
+  owner_not_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickLower_lt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_lte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper_lt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_lte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  token0?: InputMaybe<Scalars['String']>;
+  token0_?: InputMaybe<Token_Filter>;
+  token0_contains?: InputMaybe<Scalars['String']>;
+  token0_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_ends_with?: InputMaybe<Scalars['String']>;
+  token0_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_gt?: InputMaybe<Scalars['String']>;
+  token0_gte?: InputMaybe<Scalars['String']>;
+  token0_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_lt?: InputMaybe<Scalars['String']>;
+  token0_lte?: InputMaybe<Scalars['String']>;
+  token0_not?: InputMaybe<Scalars['String']>;
+  token0_not_contains?: InputMaybe<Scalars['String']>;
+  token0_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_not_starts_with?: InputMaybe<Scalars['String']>;
+  token0_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_starts_with?: InputMaybe<Scalars['String']>;
+  token0_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1?: InputMaybe<Scalars['String']>;
+  token1_?: InputMaybe<Token_Filter>;
+  token1_contains?: InputMaybe<Scalars['String']>;
+  token1_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_ends_with?: InputMaybe<Scalars['String']>;
+  token1_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_gt?: InputMaybe<Scalars['String']>;
+  token1_gte?: InputMaybe<Scalars['String']>;
+  token1_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_lt?: InputMaybe<Scalars['String']>;
+  token1_lte?: InputMaybe<Scalars['String']>;
+  token1_not?: InputMaybe<Scalars['String']>;
+  token1_not_contains?: InputMaybe<Scalars['String']>;
+  token1_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_not_starts_with?: InputMaybe<Scalars['String']>;
+  token1_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_starts_with?: InputMaybe<Scalars['String']>;
+  token1_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+};
+
+export enum Burn_OrderBy {
+  Amount = 'amount',
+  Amount0 = 'amount0',
+  Amount1 = 'amount1',
+  AmountUsd = 'amountUSD',
+  Id = 'id',
+  LogIndex = 'logIndex',
+  Origin = 'origin',
+  Owner = 'owner',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  TickLower = 'tickLower',
+  TickUpper = 'tickUpper',
+  Timestamp = 'timestamp',
+  Token0 = 'token0',
+  Token0Decimals = 'token0__decimals',
+  Token0DerivedEth = 'token0__derivedETH',
+  Token0FeesUsd = 'token0__feesUSD',
+  Token0Id = 'token0__id',
+  Token0Name = 'token0__name',
+  Token0PoolCount = 'token0__poolCount',
+  Token0Symbol = 'token0__symbol',
+  Token0TotalSupply = 'token0__totalSupply',
+  Token0TotalValueLocked = 'token0__totalValueLocked',
+  Token0TotalValueLockedUsd = 'token0__totalValueLockedUSD',
+  Token0TotalValueLockedUsdUntracked = 'token0__totalValueLockedUSDUntracked',
+  Token0TxCount = 'token0__txCount',
+  Token0UntrackedVolumeUsd = 'token0__untrackedVolumeUSD',
+  Token0Volume = 'token0__volume',
+  Token0VolumeUsd = 'token0__volumeUSD',
+  Token1 = 'token1',
+  Token1Decimals = 'token1__decimals',
+  Token1DerivedEth = 'token1__derivedETH',
+  Token1FeesUsd = 'token1__feesUSD',
+  Token1Id = 'token1__id',
+  Token1Name = 'token1__name',
+  Token1PoolCount = 'token1__poolCount',
+  Token1Symbol = 'token1__symbol',
+  Token1TotalSupply = 'token1__totalSupply',
+  Token1TotalValueLocked = 'token1__totalValueLocked',
+  Token1TotalValueLockedUsd = 'token1__totalValueLockedUSD',
+  Token1TotalValueLockedUsdUntracked = 'token1__totalValueLockedUSDUntracked',
+  Token1TxCount = 'token1__txCount',
+  Token1UntrackedVolumeUsd = 'token1__untrackedVolumeUSD',
+  Token1Volume = 'token1__volume',
+  Token1VolumeUsd = 'token1__volumeUSD',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp'
+}
+
+export type Collect = {
+  __typename?: 'Collect';
+  amount0: Scalars['BigDecimal'];
+  amount1: Scalars['BigDecimal'];
+  amountUSD?: Maybe<Scalars['BigDecimal']>;
+  id: Scalars['ID'];
+  logIndex?: Maybe<Scalars['BigInt']>;
+  owner?: Maybe<Scalars['Bytes']>;
+  pool: Pool;
+  tickLower: Scalars['BigInt'];
+  tickUpper: Scalars['BigInt'];
+  timestamp: Scalars['BigInt'];
+  transaction: Transaction;
+};
+
+export type Collect_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  amount0?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  and?: InputMaybe<Array<InputMaybe<Collect_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  logIndex?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  logIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Collect_Filter>>>;
+  owner?: InputMaybe<Scalars['Bytes']>;
+  owner_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_gt?: InputMaybe<Scalars['Bytes']>;
+  owner_gte?: InputMaybe<Scalars['Bytes']>;
+  owner_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner_lt?: InputMaybe<Scalars['Bytes']>;
+  owner_lte?: InputMaybe<Scalars['Bytes']>;
+  owner_not?: InputMaybe<Scalars['Bytes']>;
+  owner_not_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickLower_lt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_lte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper_lt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_lte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+};
+
+export enum Collect_OrderBy {
+  Amount0 = 'amount0',
+  Amount1 = 'amount1',
+  AmountUsd = 'amountUSD',
+  Id = 'id',
+  LogIndex = 'logIndex',
+  Owner = 'owner',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  TickLower = 'tickLower',
+  TickUpper = 'tickUpper',
+  Timestamp = 'timestamp',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp'
+}
+
+export type Factory = {
+  __typename?: 'Factory';
+  id: Scalars['ID'];
+  owner: Scalars['ID'];
+  poolCount: Scalars['BigInt'];
+  totalFeesETH: Scalars['BigDecimal'];
+  totalFeesUSD: Scalars['BigDecimal'];
+  totalValueLockedETH: Scalars['BigDecimal'];
+  totalValueLockedETHUntracked: Scalars['BigDecimal'];
+  totalValueLockedUSD: Scalars['BigDecimal'];
+  totalValueLockedUSDUntracked: Scalars['BigDecimal'];
+  totalVolumeETH: Scalars['BigDecimal'];
+  totalVolumeUSD: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+};
+
+export type Factory_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Factory_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  or?: InputMaybe<Array<InputMaybe<Factory_Filter>>>;
+  owner?: InputMaybe<Scalars['ID']>;
+  owner_gt?: InputMaybe<Scalars['ID']>;
+  owner_gte?: InputMaybe<Scalars['ID']>;
+  owner_in?: InputMaybe<Array<Scalars['ID']>>;
+  owner_lt?: InputMaybe<Scalars['ID']>;
+  owner_lte?: InputMaybe<Scalars['ID']>;
+  owner_not?: InputMaybe<Scalars['ID']>;
+  owner_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  poolCount?: InputMaybe<Scalars['BigInt']>;
+  poolCount_gt?: InputMaybe<Scalars['BigInt']>;
+  poolCount_gte?: InputMaybe<Scalars['BigInt']>;
+  poolCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  poolCount_lt?: InputMaybe<Scalars['BigInt']>;
+  poolCount_lte?: InputMaybe<Scalars['BigInt']>;
+  poolCount_not?: InputMaybe<Scalars['BigInt']>;
+  poolCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  totalFeesETH?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalFeesETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalFeesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalFeesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalFeesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedETH?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedETHUntracked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETHUntracked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSDUntracked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalVolumeETH?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalVolumeETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum Factory_OrderBy {
+  Id = 'id',
+  Owner = 'owner',
+  PoolCount = 'poolCount',
+  TotalFeesEth = 'totalFeesETH',
+  TotalFeesUsd = 'totalFeesUSD',
+  TotalValueLockedEth = 'totalValueLockedETH',
+  TotalValueLockedEthUntracked = 'totalValueLockedETHUntracked',
+  TotalValueLockedUsd = 'totalValueLockedUSD',
+  TotalValueLockedUsdUntracked = 'totalValueLockedUSDUntracked',
+  TotalVolumeEth = 'totalVolumeETH',
+  TotalVolumeUsd = 'totalVolumeUSD',
+  TxCount = 'txCount',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD'
+}
+
+export type Flash = {
+  __typename?: 'Flash';
+  amount0: Scalars['BigDecimal'];
+  amount0Paid: Scalars['BigDecimal'];
+  amount1: Scalars['BigDecimal'];
+  amount1Paid: Scalars['BigDecimal'];
+  amountUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  logIndex?: Maybe<Scalars['BigInt']>;
+  pool: Pool;
+  recipient: Scalars['Bytes'];
+  sender: Scalars['Bytes'];
+  timestamp: Scalars['BigInt'];
+  transaction: Transaction;
+};
+
+export type Flash_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  amount0?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0Paid_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0Paid_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1Paid_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1Paid_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  and?: InputMaybe<Array<InputMaybe<Flash_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  logIndex?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  logIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Flash_Filter>>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  recipient?: InputMaybe<Scalars['Bytes']>;
+  recipient_contains?: InputMaybe<Scalars['Bytes']>;
+  recipient_gt?: InputMaybe<Scalars['Bytes']>;
+  recipient_gte?: InputMaybe<Scalars['Bytes']>;
+  recipient_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  recipient_lt?: InputMaybe<Scalars['Bytes']>;
+  recipient_lte?: InputMaybe<Scalars['Bytes']>;
+  recipient_not?: InputMaybe<Scalars['Bytes']>;
+  recipient_not_contains?: InputMaybe<Scalars['Bytes']>;
+  recipient_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sender?: InputMaybe<Scalars['Bytes']>;
+  sender_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_gt?: InputMaybe<Scalars['Bytes']>;
+  sender_gte?: InputMaybe<Scalars['Bytes']>;
+  sender_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sender_lt?: InputMaybe<Scalars['Bytes']>;
+  sender_lte?: InputMaybe<Scalars['Bytes']>;
+  sender_not?: InputMaybe<Scalars['Bytes']>;
+  sender_not_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+};
+
+export enum Flash_OrderBy {
+  Amount0 = 'amount0',
+  Amount0Paid = 'amount0Paid',
+  Amount1 = 'amount1',
+  Amount1Paid = 'amount1Paid',
+  AmountUsd = 'amountUSD',
+  Id = 'id',
+  LogIndex = 'logIndex',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Recipient = 'recipient',
+  Sender = 'sender',
+  Timestamp = 'timestamp',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp'
+}
+
+export type Mint = {
+  __typename?: 'Mint';
+  amount: Scalars['BigInt'];
+  amount0: Scalars['BigDecimal'];
+  amount1: Scalars['BigDecimal'];
+  amountUSD?: Maybe<Scalars['BigDecimal']>;
+  id: Scalars['ID'];
+  logIndex?: Maybe<Scalars['BigInt']>;
+  origin: Scalars['Bytes'];
+  owner: Scalars['Bytes'];
+  pool: Pool;
+  sender?: Maybe<Scalars['Bytes']>;
+  tickLower: Scalars['BigInt'];
+  tickUpper: Scalars['BigInt'];
+  timestamp: Scalars['BigInt'];
+  token0: Token;
+  token1: Token;
+  transaction: Transaction;
+};
+
+export type Mint_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  amount?: InputMaybe<Scalars['BigInt']>;
+  amount0?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount_gt?: InputMaybe<Scalars['BigInt']>;
+  amount_gte?: InputMaybe<Scalars['BigInt']>;
+  amount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  amount_lt?: InputMaybe<Scalars['BigInt']>;
+  amount_lte?: InputMaybe<Scalars['BigInt']>;
+  amount_not?: InputMaybe<Scalars['BigInt']>;
+  amount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  and?: InputMaybe<Array<InputMaybe<Mint_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  logIndex?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  logIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Mint_Filter>>>;
+  origin?: InputMaybe<Scalars['Bytes']>;
+  origin_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_gt?: InputMaybe<Scalars['Bytes']>;
+  origin_gte?: InputMaybe<Scalars['Bytes']>;
+  origin_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  origin_lt?: InputMaybe<Scalars['Bytes']>;
+  origin_lte?: InputMaybe<Scalars['Bytes']>;
+  origin_not?: InputMaybe<Scalars['Bytes']>;
+  origin_not_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner?: InputMaybe<Scalars['Bytes']>;
+  owner_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_gt?: InputMaybe<Scalars['Bytes']>;
+  owner_gte?: InputMaybe<Scalars['Bytes']>;
+  owner_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner_lt?: InputMaybe<Scalars['Bytes']>;
+  owner_lte?: InputMaybe<Scalars['Bytes']>;
+  owner_not?: InputMaybe<Scalars['Bytes']>;
+  owner_not_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  sender?: InputMaybe<Scalars['Bytes']>;
+  sender_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_gt?: InputMaybe<Scalars['Bytes']>;
+  sender_gte?: InputMaybe<Scalars['Bytes']>;
+  sender_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sender_lt?: InputMaybe<Scalars['Bytes']>;
+  sender_lte?: InputMaybe<Scalars['Bytes']>;
+  sender_not?: InputMaybe<Scalars['Bytes']>;
+  sender_not_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  tickLower?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_gte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickLower_lt?: InputMaybe<Scalars['BigInt']>;
+  tickLower_lte?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not?: InputMaybe<Scalars['BigInt']>;
+  tickLower_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_gte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickUpper_lt?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_lte?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not?: InputMaybe<Scalars['BigInt']>;
+  tickUpper_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  token0?: InputMaybe<Scalars['String']>;
+  token0_?: InputMaybe<Token_Filter>;
+  token0_contains?: InputMaybe<Scalars['String']>;
+  token0_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_ends_with?: InputMaybe<Scalars['String']>;
+  token0_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_gt?: InputMaybe<Scalars['String']>;
+  token0_gte?: InputMaybe<Scalars['String']>;
+  token0_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_lt?: InputMaybe<Scalars['String']>;
+  token0_lte?: InputMaybe<Scalars['String']>;
+  token0_not?: InputMaybe<Scalars['String']>;
+  token0_not_contains?: InputMaybe<Scalars['String']>;
+  token0_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_not_starts_with?: InputMaybe<Scalars['String']>;
+  token0_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_starts_with?: InputMaybe<Scalars['String']>;
+  token0_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1?: InputMaybe<Scalars['String']>;
+  token1_?: InputMaybe<Token_Filter>;
+  token1_contains?: InputMaybe<Scalars['String']>;
+  token1_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_ends_with?: InputMaybe<Scalars['String']>;
+  token1_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_gt?: InputMaybe<Scalars['String']>;
+  token1_gte?: InputMaybe<Scalars['String']>;
+  token1_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_lt?: InputMaybe<Scalars['String']>;
+  token1_lte?: InputMaybe<Scalars['String']>;
+  token1_not?: InputMaybe<Scalars['String']>;
+  token1_not_contains?: InputMaybe<Scalars['String']>;
+  token1_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_not_starts_with?: InputMaybe<Scalars['String']>;
+  token1_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_starts_with?: InputMaybe<Scalars['String']>;
+  token1_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+};
+
+export enum Mint_OrderBy {
+  Amount = 'amount',
+  Amount0 = 'amount0',
+  Amount1 = 'amount1',
+  AmountUsd = 'amountUSD',
+  Id = 'id',
+  LogIndex = 'logIndex',
+  Origin = 'origin',
+  Owner = 'owner',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Sender = 'sender',
+  TickLower = 'tickLower',
+  TickUpper = 'tickUpper',
+  Timestamp = 'timestamp',
+  Token0 = 'token0',
+  Token0Decimals = 'token0__decimals',
+  Token0DerivedEth = 'token0__derivedETH',
+  Token0FeesUsd = 'token0__feesUSD',
+  Token0Id = 'token0__id',
+  Token0Name = 'token0__name',
+  Token0PoolCount = 'token0__poolCount',
+  Token0Symbol = 'token0__symbol',
+  Token0TotalSupply = 'token0__totalSupply',
+  Token0TotalValueLocked = 'token0__totalValueLocked',
+  Token0TotalValueLockedUsd = 'token0__totalValueLockedUSD',
+  Token0TotalValueLockedUsdUntracked = 'token0__totalValueLockedUSDUntracked',
+  Token0TxCount = 'token0__txCount',
+  Token0UntrackedVolumeUsd = 'token0__untrackedVolumeUSD',
+  Token0Volume = 'token0__volume',
+  Token0VolumeUsd = 'token0__volumeUSD',
+  Token1 = 'token1',
+  Token1Decimals = 'token1__decimals',
+  Token1DerivedEth = 'token1__derivedETH',
+  Token1FeesUsd = 'token1__feesUSD',
+  Token1Id = 'token1__id',
+  Token1Name = 'token1__name',
+  Token1PoolCount = 'token1__poolCount',
+  Token1Symbol = 'token1__symbol',
+  Token1TotalSupply = 'token1__totalSupply',
+  Token1TotalValueLocked = 'token1__totalValueLocked',
+  Token1TotalValueLockedUsd = 'token1__totalValueLockedUSD',
+  Token1TotalValueLockedUsdUntracked = 'token1__totalValueLockedUSDUntracked',
+  Token1TxCount = 'token1__txCount',
+  Token1UntrackedVolumeUsd = 'token1__untrackedVolumeUSD',
+  Token1Volume = 'token1__volume',
+  Token1VolumeUsd = 'token1__volumeUSD',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp'
+}
+
+/** Defines the order direction, either ascending or descending */
+export enum OrderDirection {
+  Asc = 'asc',
+  Desc = 'desc'
+}
+
+export type Pool = {
+  __typename?: 'Pool';
+  burns: Array<Burn>;
+  collectedFeesToken0: Scalars['BigDecimal'];
+  collectedFeesToken1: Scalars['BigDecimal'];
+  collectedFeesUSD: Scalars['BigDecimal'];
+  collects: Array<Collect>;
+  createdAtBlockNumber: Scalars['BigInt'];
+  createdAtTimestamp: Scalars['BigInt'];
+  feeGrowthGlobal0X128: Scalars['BigInt'];
+  feeGrowthGlobal1X128: Scalars['BigInt'];
+  feeTier: Scalars['BigInt'];
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidity: Scalars['BigInt'];
+  liquidityProviderCount: Scalars['BigInt'];
+  mints: Array<Mint>;
+  observationIndex: Scalars['BigInt'];
+  poolDayData: Array<PoolDayData>;
+  poolHourData: Array<PoolHourData>;
+  sqrtPrice: Scalars['BigInt'];
+  swaps: Array<Swap>;
+  tick?: Maybe<Scalars['BigInt']>;
+  ticks: Array<Tick>;
+  token0: Token;
+  token0Price: Scalars['BigDecimal'];
+  token1: Token;
+  token1Price: Scalars['BigDecimal'];
+  totalValueLockedETH: Scalars['BigDecimal'];
+  totalValueLockedToken0: Scalars['BigDecimal'];
+  totalValueLockedToken1: Scalars['BigDecimal'];
+  totalValueLockedUSD: Scalars['BigDecimal'];
+  totalValueLockedUSDUntracked: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+
+export type PoolBurnsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Burn_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Burn_Filter>;
+};
+
+
+export type PoolCollectsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Collect_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Collect_Filter>;
+};
+
+
+export type PoolMintsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Mint_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Mint_Filter>;
+};
+
+
+export type PoolPoolDayDataArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<PoolDayData_Filter>;
+};
+
+
+export type PoolPoolHourDataArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<PoolHourData_Filter>;
+};
+
+
+export type PoolSwapsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Swap_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Swap_Filter>;
+};
+
+
+export type PoolTicksArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Tick_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Tick_Filter>;
+};
+
+export type PoolDayData = {
+  __typename?: 'PoolDayData';
+  close: Scalars['BigDecimal'];
+  date: Scalars['Int'];
+  feeGrowthGlobal0X128: Scalars['BigInt'];
+  feeGrowthGlobal1X128: Scalars['BigInt'];
+  feesUSD: Scalars['BigDecimal'];
+  high: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidity: Scalars['BigInt'];
+  low: Scalars['BigDecimal'];
+  open: Scalars['BigDecimal'];
+  pool: Pool;
+  sqrtPrice: Scalars['BigInt'];
+  tick?: Maybe<Scalars['BigInt']>;
+  token0Price: Scalars['BigDecimal'];
+  token1Price: Scalars['BigDecimal'];
+  tvlUSD: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type PoolDayData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<PoolDayData_Filter>>>;
+  close?: InputMaybe<Scalars['BigDecimal']>;
+  close_gt?: InputMaybe<Scalars['BigDecimal']>;
+  close_gte?: InputMaybe<Scalars['BigDecimal']>;
+  close_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close_lt?: InputMaybe<Scalars['BigDecimal']>;
+  close_lte?: InputMaybe<Scalars['BigDecimal']>;
+  close_not?: InputMaybe<Scalars['BigDecimal']>;
+  close_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  date?: InputMaybe<Scalars['Int']>;
+  date_gt?: InputMaybe<Scalars['Int']>;
+  date_gte?: InputMaybe<Scalars['Int']>;
+  date_in?: InputMaybe<Array<Scalars['Int']>>;
+  date_lt?: InputMaybe<Scalars['Int']>;
+  date_lte?: InputMaybe<Scalars['Int']>;
+  date_not?: InputMaybe<Scalars['Int']>;
+  date_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  feeGrowthGlobal0X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal0X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high?: InputMaybe<Scalars['BigDecimal']>;
+  high_gt?: InputMaybe<Scalars['BigDecimal']>;
+  high_gte?: InputMaybe<Scalars['BigDecimal']>;
+  high_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high_lt?: InputMaybe<Scalars['BigDecimal']>;
+  high_lte?: InputMaybe<Scalars['BigDecimal']>;
+  high_not?: InputMaybe<Scalars['BigDecimal']>;
+  high_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidity?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  low?: InputMaybe<Scalars['BigDecimal']>;
+  low_gt?: InputMaybe<Scalars['BigDecimal']>;
+  low_gte?: InputMaybe<Scalars['BigDecimal']>;
+  low_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low_lt?: InputMaybe<Scalars['BigDecimal']>;
+  low_lte?: InputMaybe<Scalars['BigDecimal']>;
+  low_not?: InputMaybe<Scalars['BigDecimal']>;
+  low_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open?: InputMaybe<Scalars['BigDecimal']>;
+  open_gt?: InputMaybe<Scalars['BigDecimal']>;
+  open_gte?: InputMaybe<Scalars['BigDecimal']>;
+  open_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open_lt?: InputMaybe<Scalars['BigDecimal']>;
+  open_lte?: InputMaybe<Scalars['BigDecimal']>;
+  open_not?: InputMaybe<Scalars['BigDecimal']>;
+  open_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  or?: InputMaybe<Array<InputMaybe<PoolDayData_Filter>>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  sqrtPrice?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  sqrtPrice_lt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_lte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  token0Price?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token0Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1Price?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tvlUSD?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tvlUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum PoolDayData_OrderBy {
+  Close = 'close',
+  Date = 'date',
+  FeeGrowthGlobal0X128 = 'feeGrowthGlobal0X128',
+  FeeGrowthGlobal1X128 = 'feeGrowthGlobal1X128',
+  FeesUsd = 'feesUSD',
+  High = 'high',
+  Id = 'id',
+  Liquidity = 'liquidity',
+  Low = 'low',
+  Open = 'open',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  SqrtPrice = 'sqrtPrice',
+  Tick = 'tick',
+  Token0Price = 'token0Price',
+  Token1Price = 'token1Price',
+  TvlUsd = 'tvlUSD',
+  TxCount = 'txCount',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type PoolHourData = {
+  __typename?: 'PoolHourData';
+  close: Scalars['BigDecimal'];
+  feeGrowthGlobal0X128: Scalars['BigInt'];
+  feeGrowthGlobal1X128: Scalars['BigInt'];
+  feesUSD: Scalars['BigDecimal'];
+  high: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidity: Scalars['BigInt'];
+  low: Scalars['BigDecimal'];
+  open: Scalars['BigDecimal'];
+  periodStartUnix: Scalars['Int'];
+  pool: Pool;
+  sqrtPrice: Scalars['BigInt'];
+  tick?: Maybe<Scalars['BigInt']>;
+  token0Price: Scalars['BigDecimal'];
+  token1Price: Scalars['BigDecimal'];
+  tvlUSD: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type PoolHourData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<PoolHourData_Filter>>>;
+  close?: InputMaybe<Scalars['BigDecimal']>;
+  close_gt?: InputMaybe<Scalars['BigDecimal']>;
+  close_gte?: InputMaybe<Scalars['BigDecimal']>;
+  close_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close_lt?: InputMaybe<Scalars['BigDecimal']>;
+  close_lte?: InputMaybe<Scalars['BigDecimal']>;
+  close_not?: InputMaybe<Scalars['BigDecimal']>;
+  close_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feeGrowthGlobal0X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal0X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high?: InputMaybe<Scalars['BigDecimal']>;
+  high_gt?: InputMaybe<Scalars['BigDecimal']>;
+  high_gte?: InputMaybe<Scalars['BigDecimal']>;
+  high_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high_lt?: InputMaybe<Scalars['BigDecimal']>;
+  high_lte?: InputMaybe<Scalars['BigDecimal']>;
+  high_not?: InputMaybe<Scalars['BigDecimal']>;
+  high_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidity?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  low?: InputMaybe<Scalars['BigDecimal']>;
+  low_gt?: InputMaybe<Scalars['BigDecimal']>;
+  low_gte?: InputMaybe<Scalars['BigDecimal']>;
+  low_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low_lt?: InputMaybe<Scalars['BigDecimal']>;
+  low_lte?: InputMaybe<Scalars['BigDecimal']>;
+  low_not?: InputMaybe<Scalars['BigDecimal']>;
+  low_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open?: InputMaybe<Scalars['BigDecimal']>;
+  open_gt?: InputMaybe<Scalars['BigDecimal']>;
+  open_gte?: InputMaybe<Scalars['BigDecimal']>;
+  open_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open_lt?: InputMaybe<Scalars['BigDecimal']>;
+  open_lte?: InputMaybe<Scalars['BigDecimal']>;
+  open_not?: InputMaybe<Scalars['BigDecimal']>;
+  open_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  or?: InputMaybe<Array<InputMaybe<PoolHourData_Filter>>>;
+  periodStartUnix?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_in?: InputMaybe<Array<Scalars['Int']>>;
+  periodStartUnix_lt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_lte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  sqrtPrice?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  sqrtPrice_lt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_lte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  token0Price?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token0Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1Price?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tvlUSD?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tvlUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum PoolHourData_OrderBy {
+  Close = 'close',
+  FeeGrowthGlobal0X128 = 'feeGrowthGlobal0X128',
+  FeeGrowthGlobal1X128 = 'feeGrowthGlobal1X128',
+  FeesUsd = 'feesUSD',
+  High = 'high',
+  Id = 'id',
+  Liquidity = 'liquidity',
+  Low = 'low',
+  Open = 'open',
+  PeriodStartUnix = 'periodStartUnix',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  SqrtPrice = 'sqrtPrice',
+  Tick = 'tick',
+  Token0Price = 'token0Price',
+  Token1Price = 'token1Price',
+  TvlUsd = 'tvlUSD',
+  TxCount = 'txCount',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type Pool_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Pool_Filter>>>;
+  burns_?: InputMaybe<Burn_Filter>;
+  collectedFeesToken0?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collects_?: InputMaybe<Collect_Filter>;
+  createdAtBlockNumber?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_gt?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_gte?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtBlockNumber_lt?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_lte?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_not?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtTimestamp?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtTimestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_not?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal0X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal0X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal0X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthGlobal1X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthGlobal1X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeTier?: InputMaybe<Scalars['BigInt']>;
+  feeTier_gt?: InputMaybe<Scalars['BigInt']>;
+  feeTier_gte?: InputMaybe<Scalars['BigInt']>;
+  feeTier_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeTier_lt?: InputMaybe<Scalars['BigInt']>;
+  feeTier_lte?: InputMaybe<Scalars['BigInt']>;
+  feeTier_not?: InputMaybe<Scalars['BigInt']>;
+  feeTier_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidity?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityProviderCount_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  mints_?: InputMaybe<Mint_Filter>;
+  observationIndex?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  observationIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_not?: InputMaybe<Scalars['BigInt']>;
+  observationIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Pool_Filter>>>;
+  poolDayData_?: InputMaybe<PoolDayData_Filter>;
+  poolHourData_?: InputMaybe<PoolHourData_Filter>;
+  sqrtPrice?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_gte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  sqrtPrice_lt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_lte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not?: InputMaybe<Scalars['BigInt']>;
+  sqrtPrice_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  swaps_?: InputMaybe<Swap_Filter>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  ticks_?: InputMaybe<Tick_Filter>;
+  token0?: InputMaybe<Scalars['String']>;
+  token0Price?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token0Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token0Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token0_?: InputMaybe<Token_Filter>;
+  token0_contains?: InputMaybe<Scalars['String']>;
+  token0_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_ends_with?: InputMaybe<Scalars['String']>;
+  token0_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_gt?: InputMaybe<Scalars['String']>;
+  token0_gte?: InputMaybe<Scalars['String']>;
+  token0_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_lt?: InputMaybe<Scalars['String']>;
+  token0_lte?: InputMaybe<Scalars['String']>;
+  token0_not?: InputMaybe<Scalars['String']>;
+  token0_not_contains?: InputMaybe<Scalars['String']>;
+  token0_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_not_starts_with?: InputMaybe<Scalars['String']>;
+  token0_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_starts_with?: InputMaybe<Scalars['String']>;
+  token0_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1?: InputMaybe<Scalars['String']>;
+  token1Price?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_gte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1Price_lt?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_lte?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not?: InputMaybe<Scalars['BigDecimal']>;
+  token1Price_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token1_?: InputMaybe<Token_Filter>;
+  token1_contains?: InputMaybe<Scalars['String']>;
+  token1_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_ends_with?: InputMaybe<Scalars['String']>;
+  token1_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_gt?: InputMaybe<Scalars['String']>;
+  token1_gte?: InputMaybe<Scalars['String']>;
+  token1_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_lt?: InputMaybe<Scalars['String']>;
+  token1_lte?: InputMaybe<Scalars['String']>;
+  token1_not?: InputMaybe<Scalars['String']>;
+  token1_not_contains?: InputMaybe<Scalars['String']>;
+  token1_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_not_starts_with?: InputMaybe<Scalars['String']>;
+  token1_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_starts_with?: InputMaybe<Scalars['String']>;
+  token1_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  totalValueLockedETH?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedToken0?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedToken1?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSDUntracked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum Pool_OrderBy {
+  Burns = 'burns',
+  CollectedFeesToken0 = 'collectedFeesToken0',
+  CollectedFeesToken1 = 'collectedFeesToken1',
+  CollectedFeesUsd = 'collectedFeesUSD',
+  Collects = 'collects',
+  CreatedAtBlockNumber = 'createdAtBlockNumber',
+  CreatedAtTimestamp = 'createdAtTimestamp',
+  FeeGrowthGlobal0X128 = 'feeGrowthGlobal0X128',
+  FeeGrowthGlobal1X128 = 'feeGrowthGlobal1X128',
+  FeeTier = 'feeTier',
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  Liquidity = 'liquidity',
+  LiquidityProviderCount = 'liquidityProviderCount',
+  Mints = 'mints',
+  ObservationIndex = 'observationIndex',
+  PoolDayData = 'poolDayData',
+  PoolHourData = 'poolHourData',
+  SqrtPrice = 'sqrtPrice',
+  Swaps = 'swaps',
+  Tick = 'tick',
+  Ticks = 'ticks',
+  Token0 = 'token0',
+  Token0Price = 'token0Price',
+  Token0Decimals = 'token0__decimals',
+  Token0DerivedEth = 'token0__derivedETH',
+  Token0FeesUsd = 'token0__feesUSD',
+  Token0Id = 'token0__id',
+  Token0Name = 'token0__name',
+  Token0PoolCount = 'token0__poolCount',
+  Token0Symbol = 'token0__symbol',
+  Token0TotalSupply = 'token0__totalSupply',
+  Token0TotalValueLocked = 'token0__totalValueLocked',
+  Token0TotalValueLockedUsd = 'token0__totalValueLockedUSD',
+  Token0TotalValueLockedUsdUntracked = 'token0__totalValueLockedUSDUntracked',
+  Token0TxCount = 'token0__txCount',
+  Token0UntrackedVolumeUsd = 'token0__untrackedVolumeUSD',
+  Token0Volume = 'token0__volume',
+  Token0VolumeUsd = 'token0__volumeUSD',
+  Token1 = 'token1',
+  Token1Price = 'token1Price',
+  Token1Decimals = 'token1__decimals',
+  Token1DerivedEth = 'token1__derivedETH',
+  Token1FeesUsd = 'token1__feesUSD',
+  Token1Id = 'token1__id',
+  Token1Name = 'token1__name',
+  Token1PoolCount = 'token1__poolCount',
+  Token1Symbol = 'token1__symbol',
+  Token1TotalSupply = 'token1__totalSupply',
+  Token1TotalValueLocked = 'token1__totalValueLocked',
+  Token1TotalValueLockedUsd = 'token1__totalValueLockedUSD',
+  Token1TotalValueLockedUsdUntracked = 'token1__totalValueLockedUSDUntracked',
+  Token1TxCount = 'token1__txCount',
+  Token1UntrackedVolumeUsd = 'token1__untrackedVolumeUSD',
+  Token1Volume = 'token1__volume',
+  Token1VolumeUsd = 'token1__volumeUSD',
+  TotalValueLockedEth = 'totalValueLockedETH',
+  TotalValueLockedToken0 = 'totalValueLockedToken0',
+  TotalValueLockedToken1 = 'totalValueLockedToken1',
+  TotalValueLockedUsd = 'totalValueLockedUSD',
+  TotalValueLockedUsdUntracked = 'totalValueLockedUSDUntracked',
+  TxCount = 'txCount',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type Position = {
+  __typename?: 'Position';
+  collectedFeesToken0: Scalars['BigDecimal'];
+  collectedFeesToken1: Scalars['BigDecimal'];
+  depositedToken0: Scalars['BigDecimal'];
+  depositedToken1: Scalars['BigDecimal'];
+  feeGrowthInside0LastX128: Scalars['BigInt'];
+  feeGrowthInside1LastX128: Scalars['BigInt'];
+  id: Scalars['ID'];
+  liquidity: Scalars['BigInt'];
+  owner: Scalars['Bytes'];
+  pool: Pool;
+  tickLower: Tick;
+  tickUpper: Tick;
+  token0: Token;
+  token1: Token;
+  transaction: Transaction;
+  withdrawnToken0: Scalars['BigDecimal'];
+  withdrawnToken1: Scalars['BigDecimal'];
+};
+
+export type PositionSnapshot = {
+  __typename?: 'PositionSnapshot';
+  blockNumber: Scalars['BigInt'];
+  collectedFeesToken0: Scalars['BigDecimal'];
+  collectedFeesToken1: Scalars['BigDecimal'];
+  depositedToken0: Scalars['BigDecimal'];
+  depositedToken1: Scalars['BigDecimal'];
+  feeGrowthInside0LastX128: Scalars['BigInt'];
+  feeGrowthInside1LastX128: Scalars['BigInt'];
+  id: Scalars['ID'];
+  liquidity: Scalars['BigInt'];
+  owner: Scalars['Bytes'];
+  pool: Pool;
+  position: Position;
+  timestamp: Scalars['BigInt'];
+  transaction: Transaction;
+  withdrawnToken0: Scalars['BigDecimal'];
+  withdrawnToken1: Scalars['BigDecimal'];
+};
+
+export type PositionSnapshot_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<PositionSnapshot_Filter>>>;
+  blockNumber?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_gt?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_gte?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  blockNumber_lt?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_lte?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_not?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  collectedFeesToken0?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken0?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken1?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feeGrowthInside0LastX128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside0LastX128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside1LastX128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside1LastX128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidity?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<PositionSnapshot_Filter>>>;
+  owner?: InputMaybe<Scalars['Bytes']>;
+  owner_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_gt?: InputMaybe<Scalars['Bytes']>;
+  owner_gte?: InputMaybe<Scalars['Bytes']>;
+  owner_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner_lt?: InputMaybe<Scalars['Bytes']>;
+  owner_lte?: InputMaybe<Scalars['Bytes']>;
+  owner_not?: InputMaybe<Scalars['Bytes']>;
+  owner_not_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  position?: InputMaybe<Scalars['String']>;
+  position_?: InputMaybe<Position_Filter>;
+  position_contains?: InputMaybe<Scalars['String']>;
+  position_contains_nocase?: InputMaybe<Scalars['String']>;
+  position_ends_with?: InputMaybe<Scalars['String']>;
+  position_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  position_gt?: InputMaybe<Scalars['String']>;
+  position_gte?: InputMaybe<Scalars['String']>;
+  position_in?: InputMaybe<Array<Scalars['String']>>;
+  position_lt?: InputMaybe<Scalars['String']>;
+  position_lte?: InputMaybe<Scalars['String']>;
+  position_not?: InputMaybe<Scalars['String']>;
+  position_not_contains?: InputMaybe<Scalars['String']>;
+  position_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  position_not_ends_with?: InputMaybe<Scalars['String']>;
+  position_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  position_not_in?: InputMaybe<Array<Scalars['String']>>;
+  position_not_starts_with?: InputMaybe<Scalars['String']>;
+  position_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  position_starts_with?: InputMaybe<Scalars['String']>;
+  position_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  withdrawnToken0?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken1?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum PositionSnapshot_OrderBy {
+  BlockNumber = 'blockNumber',
+  CollectedFeesToken0 = 'collectedFeesToken0',
+  CollectedFeesToken1 = 'collectedFeesToken1',
+  DepositedToken0 = 'depositedToken0',
+  DepositedToken1 = 'depositedToken1',
+  FeeGrowthInside0LastX128 = 'feeGrowthInside0LastX128',
+  FeeGrowthInside1LastX128 = 'feeGrowthInside1LastX128',
+  Id = 'id',
+  Liquidity = 'liquidity',
+  Owner = 'owner',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Position = 'position',
+  PositionCollectedFeesToken0 = 'position__collectedFeesToken0',
+  PositionCollectedFeesToken1 = 'position__collectedFeesToken1',
+  PositionDepositedToken0 = 'position__depositedToken0',
+  PositionDepositedToken1 = 'position__depositedToken1',
+  PositionFeeGrowthInside0LastX128 = 'position__feeGrowthInside0LastX128',
+  PositionFeeGrowthInside1LastX128 = 'position__feeGrowthInside1LastX128',
+  PositionId = 'position__id',
+  PositionLiquidity = 'position__liquidity',
+  PositionOwner = 'position__owner',
+  PositionWithdrawnToken0 = 'position__withdrawnToken0',
+  PositionWithdrawnToken1 = 'position__withdrawnToken1',
+  Timestamp = 'timestamp',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp',
+  WithdrawnToken0 = 'withdrawnToken0',
+  WithdrawnToken1 = 'withdrawnToken1'
+}
+
+export type Position_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Position_Filter>>>;
+  collectedFeesToken0?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken0?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken1?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  depositedToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  depositedToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feeGrowthInside0LastX128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside0LastX128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside0LastX128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside1LastX128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthInside1LastX128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthInside1LastX128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidity?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidity_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidity_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not?: InputMaybe<Scalars['BigInt']>;
+  liquidity_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Position_Filter>>>;
+  owner?: InputMaybe<Scalars['Bytes']>;
+  owner_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_gt?: InputMaybe<Scalars['Bytes']>;
+  owner_gte?: InputMaybe<Scalars['Bytes']>;
+  owner_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  owner_lt?: InputMaybe<Scalars['Bytes']>;
+  owner_lte?: InputMaybe<Scalars['Bytes']>;
+  owner_not?: InputMaybe<Scalars['Bytes']>;
+  owner_not_contains?: InputMaybe<Scalars['Bytes']>;
+  owner_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower?: InputMaybe<Scalars['String']>;
+  tickLower_?: InputMaybe<Tick_Filter>;
+  tickLower_contains?: InputMaybe<Scalars['String']>;
+  tickLower_contains_nocase?: InputMaybe<Scalars['String']>;
+  tickLower_ends_with?: InputMaybe<Scalars['String']>;
+  tickLower_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower_gt?: InputMaybe<Scalars['String']>;
+  tickLower_gte?: InputMaybe<Scalars['String']>;
+  tickLower_in?: InputMaybe<Array<Scalars['String']>>;
+  tickLower_lt?: InputMaybe<Scalars['String']>;
+  tickLower_lte?: InputMaybe<Scalars['String']>;
+  tickLower_not?: InputMaybe<Scalars['String']>;
+  tickLower_not_contains?: InputMaybe<Scalars['String']>;
+  tickLower_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  tickLower_not_ends_with?: InputMaybe<Scalars['String']>;
+  tickLower_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower_not_in?: InputMaybe<Array<Scalars['String']>>;
+  tickLower_not_starts_with?: InputMaybe<Scalars['String']>;
+  tickLower_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickLower_starts_with?: InputMaybe<Scalars['String']>;
+  tickLower_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper?: InputMaybe<Scalars['String']>;
+  tickUpper_?: InputMaybe<Tick_Filter>;
+  tickUpper_contains?: InputMaybe<Scalars['String']>;
+  tickUpper_contains_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper_ends_with?: InputMaybe<Scalars['String']>;
+  tickUpper_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper_gt?: InputMaybe<Scalars['String']>;
+  tickUpper_gte?: InputMaybe<Scalars['String']>;
+  tickUpper_in?: InputMaybe<Array<Scalars['String']>>;
+  tickUpper_lt?: InputMaybe<Scalars['String']>;
+  tickUpper_lte?: InputMaybe<Scalars['String']>;
+  tickUpper_not?: InputMaybe<Scalars['String']>;
+  tickUpper_not_contains?: InputMaybe<Scalars['String']>;
+  tickUpper_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper_not_ends_with?: InputMaybe<Scalars['String']>;
+  tickUpper_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper_not_in?: InputMaybe<Array<Scalars['String']>>;
+  tickUpper_not_starts_with?: InputMaybe<Scalars['String']>;
+  tickUpper_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tickUpper_starts_with?: InputMaybe<Scalars['String']>;
+  tickUpper_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0?: InputMaybe<Scalars['String']>;
+  token0_?: InputMaybe<Token_Filter>;
+  token0_contains?: InputMaybe<Scalars['String']>;
+  token0_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_ends_with?: InputMaybe<Scalars['String']>;
+  token0_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_gt?: InputMaybe<Scalars['String']>;
+  token0_gte?: InputMaybe<Scalars['String']>;
+  token0_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_lt?: InputMaybe<Scalars['String']>;
+  token0_lte?: InputMaybe<Scalars['String']>;
+  token0_not?: InputMaybe<Scalars['String']>;
+  token0_not_contains?: InputMaybe<Scalars['String']>;
+  token0_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_not_starts_with?: InputMaybe<Scalars['String']>;
+  token0_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_starts_with?: InputMaybe<Scalars['String']>;
+  token0_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1?: InputMaybe<Scalars['String']>;
+  token1_?: InputMaybe<Token_Filter>;
+  token1_contains?: InputMaybe<Scalars['String']>;
+  token1_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_ends_with?: InputMaybe<Scalars['String']>;
+  token1_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_gt?: InputMaybe<Scalars['String']>;
+  token1_gte?: InputMaybe<Scalars['String']>;
+  token1_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_lt?: InputMaybe<Scalars['String']>;
+  token1_lte?: InputMaybe<Scalars['String']>;
+  token1_not?: InputMaybe<Scalars['String']>;
+  token1_not_contains?: InputMaybe<Scalars['String']>;
+  token1_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_not_starts_with?: InputMaybe<Scalars['String']>;
+  token1_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_starts_with?: InputMaybe<Scalars['String']>;
+  token1_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  withdrawnToken0?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken1?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  withdrawnToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  withdrawnToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum Position_OrderBy {
+  CollectedFeesToken0 = 'collectedFeesToken0',
+  CollectedFeesToken1 = 'collectedFeesToken1',
+  DepositedToken0 = 'depositedToken0',
+  DepositedToken1 = 'depositedToken1',
+  FeeGrowthInside0LastX128 = 'feeGrowthInside0LastX128',
+  FeeGrowthInside1LastX128 = 'feeGrowthInside1LastX128',
+  Id = 'id',
+  Liquidity = 'liquidity',
+  Owner = 'owner',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  TickLower = 'tickLower',
+  TickLowerCollectedFeesToken0 = 'tickLower__collectedFeesToken0',
+  TickLowerCollectedFeesToken1 = 'tickLower__collectedFeesToken1',
+  TickLowerCollectedFeesUsd = 'tickLower__collectedFeesUSD',
+  TickLowerCreatedAtBlockNumber = 'tickLower__createdAtBlockNumber',
+  TickLowerCreatedAtTimestamp = 'tickLower__createdAtTimestamp',
+  TickLowerFeeGrowthOutside0X128 = 'tickLower__feeGrowthOutside0X128',
+  TickLowerFeeGrowthOutside1X128 = 'tickLower__feeGrowthOutside1X128',
+  TickLowerFeesUsd = 'tickLower__feesUSD',
+  TickLowerId = 'tickLower__id',
+  TickLowerLiquidityGross = 'tickLower__liquidityGross',
+  TickLowerLiquidityNet = 'tickLower__liquidityNet',
+  TickLowerLiquidityProviderCount = 'tickLower__liquidityProviderCount',
+  TickLowerPoolAddress = 'tickLower__poolAddress',
+  TickLowerPrice0 = 'tickLower__price0',
+  TickLowerPrice1 = 'tickLower__price1',
+  TickLowerTickIdx = 'tickLower__tickIdx',
+  TickLowerUntrackedVolumeUsd = 'tickLower__untrackedVolumeUSD',
+  TickLowerVolumeToken0 = 'tickLower__volumeToken0',
+  TickLowerVolumeToken1 = 'tickLower__volumeToken1',
+  TickLowerVolumeUsd = 'tickLower__volumeUSD',
+  TickUpper = 'tickUpper',
+  TickUpperCollectedFeesToken0 = 'tickUpper__collectedFeesToken0',
+  TickUpperCollectedFeesToken1 = 'tickUpper__collectedFeesToken1',
+  TickUpperCollectedFeesUsd = 'tickUpper__collectedFeesUSD',
+  TickUpperCreatedAtBlockNumber = 'tickUpper__createdAtBlockNumber',
+  TickUpperCreatedAtTimestamp = 'tickUpper__createdAtTimestamp',
+  TickUpperFeeGrowthOutside0X128 = 'tickUpper__feeGrowthOutside0X128',
+  TickUpperFeeGrowthOutside1X128 = 'tickUpper__feeGrowthOutside1X128',
+  TickUpperFeesUsd = 'tickUpper__feesUSD',
+  TickUpperId = 'tickUpper__id',
+  TickUpperLiquidityGross = 'tickUpper__liquidityGross',
+  TickUpperLiquidityNet = 'tickUpper__liquidityNet',
+  TickUpperLiquidityProviderCount = 'tickUpper__liquidityProviderCount',
+  TickUpperPoolAddress = 'tickUpper__poolAddress',
+  TickUpperPrice0 = 'tickUpper__price0',
+  TickUpperPrice1 = 'tickUpper__price1',
+  TickUpperTickIdx = 'tickUpper__tickIdx',
+  TickUpperUntrackedVolumeUsd = 'tickUpper__untrackedVolumeUSD',
+  TickUpperVolumeToken0 = 'tickUpper__volumeToken0',
+  TickUpperVolumeToken1 = 'tickUpper__volumeToken1',
+  TickUpperVolumeUsd = 'tickUpper__volumeUSD',
+  Token0 = 'token0',
+  Token0Decimals = 'token0__decimals',
+  Token0DerivedEth = 'token0__derivedETH',
+  Token0FeesUsd = 'token0__feesUSD',
+  Token0Id = 'token0__id',
+  Token0Name = 'token0__name',
+  Token0PoolCount = 'token0__poolCount',
+  Token0Symbol = 'token0__symbol',
+  Token0TotalSupply = 'token0__totalSupply',
+  Token0TotalValueLocked = 'token0__totalValueLocked',
+  Token0TotalValueLockedUsd = 'token0__totalValueLockedUSD',
+  Token0TotalValueLockedUsdUntracked = 'token0__totalValueLockedUSDUntracked',
+  Token0TxCount = 'token0__txCount',
+  Token0UntrackedVolumeUsd = 'token0__untrackedVolumeUSD',
+  Token0Volume = 'token0__volume',
+  Token0VolumeUsd = 'token0__volumeUSD',
+  Token1 = 'token1',
+  Token1Decimals = 'token1__decimals',
+  Token1DerivedEth = 'token1__derivedETH',
+  Token1FeesUsd = 'token1__feesUSD',
+  Token1Id = 'token1__id',
+  Token1Name = 'token1__name',
+  Token1PoolCount = 'token1__poolCount',
+  Token1Symbol = 'token1__symbol',
+  Token1TotalSupply = 'token1__totalSupply',
+  Token1TotalValueLocked = 'token1__totalValueLocked',
+  Token1TotalValueLockedUsd = 'token1__totalValueLockedUSD',
+  Token1TotalValueLockedUsdUntracked = 'token1__totalValueLockedUSDUntracked',
+  Token1TxCount = 'token1__txCount',
+  Token1UntrackedVolumeUsd = 'token1__untrackedVolumeUSD',
+  Token1Volume = 'token1__volume',
+  Token1VolumeUsd = 'token1__volumeUSD',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp',
+  WithdrawnToken0 = 'withdrawnToken0',
+  WithdrawnToken1 = 'withdrawnToken1'
+}
+
+export type Query = {
+  __typename?: 'Query';
+  /** Access to subgraph metadata */
+  _meta?: Maybe<_Meta_>;
+  bundle?: Maybe<Bundle>;
+  bundles: Array<Bundle>;
+  burn?: Maybe<Burn>;
+  burns: Array<Burn>;
+  collect?: Maybe<Collect>;
+  collects: Array<Collect>;
+  factories: Array<Factory>;
+  factory?: Maybe<Factory>;
+  flash?: Maybe<Flash>;
+  flashes: Array<Flash>;
+  mint?: Maybe<Mint>;
+  mints: Array<Mint>;
+  pool?: Maybe<Pool>;
+  poolDayData?: Maybe<PoolDayData>;
+  poolDayDatas: Array<PoolDayData>;
+  poolHourData?: Maybe<PoolHourData>;
+  poolHourDatas: Array<PoolHourData>;
+  pools: Array<Pool>;
+  position?: Maybe<Position>;
+  positionSnapshot?: Maybe<PositionSnapshot>;
+  positionSnapshots: Array<PositionSnapshot>;
+  positions: Array<Position>;
+  swap?: Maybe<Swap>;
+  swaps: Array<Swap>;
+  tick?: Maybe<Tick>;
+  tickDayData?: Maybe<TickDayData>;
+  tickDayDatas: Array<TickDayData>;
+  tickHourData?: Maybe<TickHourData>;
+  tickHourDatas: Array<TickHourData>;
+  ticks: Array<Tick>;
+  token?: Maybe<Token>;
+  tokenDayData?: Maybe<TokenDayData>;
+  tokenDayDatas: Array<TokenDayData>;
+  tokenHourData?: Maybe<TokenHourData>;
+  tokenHourDatas: Array<TokenHourData>;
+  tokens: Array<Token>;
+  transaction?: Maybe<Transaction>;
+  transactions: Array<Transaction>;
+  uniswapDayData?: Maybe<UniswapDayData>;
+  uniswapDayDatas: Array<UniswapDayData>;
+};
+
+
+export type Query_MetaArgs = {
+  block?: InputMaybe<Block_Height>;
+};
+
+
+export type QueryBundleArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryBundlesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Bundle_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Bundle_Filter>;
+};
+
+
+export type QueryBurnArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryBurnsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Burn_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Burn_Filter>;
+};
+
+
+export type QueryCollectArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryCollectsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Collect_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Collect_Filter>;
+};
+
+
+export type QueryFactoriesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Factory_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Factory_Filter>;
+};
+
+
+export type QueryFactoryArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryFlashArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryFlashesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Flash_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Flash_Filter>;
+};
+
+
+export type QueryMintArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryMintsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Mint_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Mint_Filter>;
+};
+
+
+export type QueryPoolArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryPoolDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryPoolDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PoolDayData_Filter>;
+};
+
+
+export type QueryPoolHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryPoolHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PoolHourData_Filter>;
+};
+
+
+export type QueryPoolsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Pool_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Pool_Filter>;
+};
+
+
+export type QueryPositionArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryPositionSnapshotArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryPositionSnapshotsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PositionSnapshot_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PositionSnapshot_Filter>;
+};
+
+
+export type QueryPositionsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Position_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Position_Filter>;
+};
+
+
+export type QuerySwapArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QuerySwapsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Swap_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Swap_Filter>;
+};
+
+
+export type QueryTickArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTickDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTickDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TickDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TickDayData_Filter>;
+};
+
+
+export type QueryTickHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTickHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TickHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TickHourData_Filter>;
+};
+
+
+export type QueryTicksArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Tick_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Tick_Filter>;
+};
+
+
+export type QueryTokenArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTokenDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTokenDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TokenDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TokenDayData_Filter>;
+};
+
+
+export type QueryTokenHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTokenHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TokenHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TokenHourData_Filter>;
+};
+
+
+export type QueryTokensArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Token_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Token_Filter>;
+};
+
+
+export type QueryTransactionArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryTransactionsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Transaction_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Transaction_Filter>;
+};
+
+
+export type QueryUniswapDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type QueryUniswapDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<UniswapDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<UniswapDayData_Filter>;
+};
+
+export type Subscription = {
+  __typename?: 'Subscription';
+  /** Access to subgraph metadata */
+  _meta?: Maybe<_Meta_>;
+  bundle?: Maybe<Bundle>;
+  bundles: Array<Bundle>;
+  burn?: Maybe<Burn>;
+  burns: Array<Burn>;
+  collect?: Maybe<Collect>;
+  collects: Array<Collect>;
+  factories: Array<Factory>;
+  factory?: Maybe<Factory>;
+  flash?: Maybe<Flash>;
+  flashes: Array<Flash>;
+  mint?: Maybe<Mint>;
+  mints: Array<Mint>;
+  pool?: Maybe<Pool>;
+  poolDayData?: Maybe<PoolDayData>;
+  poolDayDatas: Array<PoolDayData>;
+  poolHourData?: Maybe<PoolHourData>;
+  poolHourDatas: Array<PoolHourData>;
+  pools: Array<Pool>;
+  position?: Maybe<Position>;
+  positionSnapshot?: Maybe<PositionSnapshot>;
+  positionSnapshots: Array<PositionSnapshot>;
+  positions: Array<Position>;
+  swap?: Maybe<Swap>;
+  swaps: Array<Swap>;
+  tick?: Maybe<Tick>;
+  tickDayData?: Maybe<TickDayData>;
+  tickDayDatas: Array<TickDayData>;
+  tickHourData?: Maybe<TickHourData>;
+  tickHourDatas: Array<TickHourData>;
+  ticks: Array<Tick>;
+  token?: Maybe<Token>;
+  tokenDayData?: Maybe<TokenDayData>;
+  tokenDayDatas: Array<TokenDayData>;
+  tokenHourData?: Maybe<TokenHourData>;
+  tokenHourDatas: Array<TokenHourData>;
+  tokens: Array<Token>;
+  transaction?: Maybe<Transaction>;
+  transactions: Array<Transaction>;
+  uniswapDayData?: Maybe<UniswapDayData>;
+  uniswapDayDatas: Array<UniswapDayData>;
+};
+
+
+export type Subscription_MetaArgs = {
+  block?: InputMaybe<Block_Height>;
+};
+
+
+export type SubscriptionBundleArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionBundlesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Bundle_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Bundle_Filter>;
+};
+
+
+export type SubscriptionBurnArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionBurnsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Burn_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Burn_Filter>;
+};
+
+
+export type SubscriptionCollectArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionCollectsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Collect_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Collect_Filter>;
+};
+
+
+export type SubscriptionFactoriesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Factory_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Factory_Filter>;
+};
+
+
+export type SubscriptionFactoryArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionFlashArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionFlashesArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Flash_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Flash_Filter>;
+};
+
+
+export type SubscriptionMintArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionMintsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Mint_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Mint_Filter>;
+};
+
+
+export type SubscriptionPoolArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionPoolDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionPoolDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PoolDayData_Filter>;
+};
+
+
+export type SubscriptionPoolHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionPoolHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PoolHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PoolHourData_Filter>;
+};
+
+
+export type SubscriptionPoolsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Pool_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Pool_Filter>;
+};
+
+
+export type SubscriptionPositionArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionPositionSnapshotArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionPositionSnapshotsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<PositionSnapshot_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<PositionSnapshot_Filter>;
+};
+
+
+export type SubscriptionPositionsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Position_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Position_Filter>;
+};
+
+
+export type SubscriptionSwapArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionSwapsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Swap_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Swap_Filter>;
+};
+
+
+export type SubscriptionTickArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTickDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTickDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TickDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TickDayData_Filter>;
+};
+
+
+export type SubscriptionTickHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTickHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TickHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TickHourData_Filter>;
+};
+
+
+export type SubscriptionTicksArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Tick_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Tick_Filter>;
+};
+
+
+export type SubscriptionTokenArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTokenDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTokenDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TokenDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TokenDayData_Filter>;
+};
+
+
+export type SubscriptionTokenHourDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTokenHourDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TokenHourData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<TokenHourData_Filter>;
+};
+
+
+export type SubscriptionTokensArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Token_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Token_Filter>;
+};
+
+
+export type SubscriptionTransactionArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionTransactionsArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Transaction_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<Transaction_Filter>;
+};
+
+
+export type SubscriptionUniswapDayDataArgs = {
+  block?: InputMaybe<Block_Height>;
+  id: Scalars['ID'];
+  subgraphError?: _SubgraphErrorPolicy_;
+};
+
+
+export type SubscriptionUniswapDayDatasArgs = {
+  block?: InputMaybe<Block_Height>;
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<UniswapDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  subgraphError?: _SubgraphErrorPolicy_;
+  where?: InputMaybe<UniswapDayData_Filter>;
+};
+
+export type Swap = {
+  __typename?: 'Swap';
+  amount0: Scalars['BigDecimal'];
+  amount1: Scalars['BigDecimal'];
+  amountUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  logIndex?: Maybe<Scalars['BigInt']>;
+  origin: Scalars['Bytes'];
+  pool: Pool;
+  recipient: Scalars['Bytes'];
+  sender: Scalars['Bytes'];
+  sqrtPriceX96: Scalars['BigInt'];
+  tick: Scalars['BigInt'];
+  timestamp: Scalars['BigInt'];
+  token0: Token;
+  token1: Token;
+  transaction: Transaction;
+};
+
+export type Swap_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  amount0?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amount1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not?: InputMaybe<Scalars['BigDecimal']>;
+  amount1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  amountUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  amountUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  and?: InputMaybe<Array<InputMaybe<Swap_Filter>>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  logIndex?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_gte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  logIndex_lt?: InputMaybe<Scalars['BigInt']>;
+  logIndex_lte?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not?: InputMaybe<Scalars['BigInt']>;
+  logIndex_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Swap_Filter>>>;
+  origin?: InputMaybe<Scalars['Bytes']>;
+  origin_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_gt?: InputMaybe<Scalars['Bytes']>;
+  origin_gte?: InputMaybe<Scalars['Bytes']>;
+  origin_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  origin_lt?: InputMaybe<Scalars['Bytes']>;
+  origin_lte?: InputMaybe<Scalars['Bytes']>;
+  origin_not?: InputMaybe<Scalars['Bytes']>;
+  origin_not_contains?: InputMaybe<Scalars['Bytes']>;
+  origin_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  recipient?: InputMaybe<Scalars['Bytes']>;
+  recipient_contains?: InputMaybe<Scalars['Bytes']>;
+  recipient_gt?: InputMaybe<Scalars['Bytes']>;
+  recipient_gte?: InputMaybe<Scalars['Bytes']>;
+  recipient_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  recipient_lt?: InputMaybe<Scalars['Bytes']>;
+  recipient_lte?: InputMaybe<Scalars['Bytes']>;
+  recipient_not?: InputMaybe<Scalars['Bytes']>;
+  recipient_not_contains?: InputMaybe<Scalars['Bytes']>;
+  recipient_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sender?: InputMaybe<Scalars['Bytes']>;
+  sender_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_gt?: InputMaybe<Scalars['Bytes']>;
+  sender_gte?: InputMaybe<Scalars['Bytes']>;
+  sender_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sender_lt?: InputMaybe<Scalars['Bytes']>;
+  sender_lte?: InputMaybe<Scalars['Bytes']>;
+  sender_not?: InputMaybe<Scalars['Bytes']>;
+  sender_not_contains?: InputMaybe<Scalars['Bytes']>;
+  sender_not_in?: InputMaybe<Array<Scalars['Bytes']>>;
+  sqrtPriceX96?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_gt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_gte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  sqrtPriceX96_lt?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_lte?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_not?: InputMaybe<Scalars['BigInt']>;
+  sqrtPriceX96_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick?: InputMaybe<Scalars['BigInt']>;
+  tick_gt?: InputMaybe<Scalars['BigInt']>;
+  tick_gte?: InputMaybe<Scalars['BigInt']>;
+  tick_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tick_lt?: InputMaybe<Scalars['BigInt']>;
+  tick_lte?: InputMaybe<Scalars['BigInt']>;
+  tick_not?: InputMaybe<Scalars['BigInt']>;
+  tick_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  token0?: InputMaybe<Scalars['String']>;
+  token0_?: InputMaybe<Token_Filter>;
+  token0_contains?: InputMaybe<Scalars['String']>;
+  token0_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_ends_with?: InputMaybe<Scalars['String']>;
+  token0_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_gt?: InputMaybe<Scalars['String']>;
+  token0_gte?: InputMaybe<Scalars['String']>;
+  token0_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_lt?: InputMaybe<Scalars['String']>;
+  token0_lte?: InputMaybe<Scalars['String']>;
+  token0_not?: InputMaybe<Scalars['String']>;
+  token0_not_contains?: InputMaybe<Scalars['String']>;
+  token0_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with?: InputMaybe<Scalars['String']>;
+  token0_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token0_not_starts_with?: InputMaybe<Scalars['String']>;
+  token0_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token0_starts_with?: InputMaybe<Scalars['String']>;
+  token0_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1?: InputMaybe<Scalars['String']>;
+  token1_?: InputMaybe<Token_Filter>;
+  token1_contains?: InputMaybe<Scalars['String']>;
+  token1_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_ends_with?: InputMaybe<Scalars['String']>;
+  token1_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_gt?: InputMaybe<Scalars['String']>;
+  token1_gte?: InputMaybe<Scalars['String']>;
+  token1_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_lt?: InputMaybe<Scalars['String']>;
+  token1_lte?: InputMaybe<Scalars['String']>;
+  token1_not?: InputMaybe<Scalars['String']>;
+  token1_not_contains?: InputMaybe<Scalars['String']>;
+  token1_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with?: InputMaybe<Scalars['String']>;
+  token1_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token1_not_starts_with?: InputMaybe<Scalars['String']>;
+  token1_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token1_starts_with?: InputMaybe<Scalars['String']>;
+  token1_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction?: InputMaybe<Scalars['String']>;
+  transaction_?: InputMaybe<Transaction_Filter>;
+  transaction_contains?: InputMaybe<Scalars['String']>;
+  transaction_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_gt?: InputMaybe<Scalars['String']>;
+  transaction_gte?: InputMaybe<Scalars['String']>;
+  transaction_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_lt?: InputMaybe<Scalars['String']>;
+  transaction_lte?: InputMaybe<Scalars['String']>;
+  transaction_not?: InputMaybe<Scalars['String']>;
+  transaction_not_contains?: InputMaybe<Scalars['String']>;
+  transaction_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with?: InputMaybe<Scalars['String']>;
+  transaction_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_not_in?: InputMaybe<Array<Scalars['String']>>;
+  transaction_not_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  transaction_starts_with?: InputMaybe<Scalars['String']>;
+  transaction_starts_with_nocase?: InputMaybe<Scalars['String']>;
+};
+
+export enum Swap_OrderBy {
+  Amount0 = 'amount0',
+  Amount1 = 'amount1',
+  AmountUsd = 'amountUSD',
+  Id = 'id',
+  LogIndex = 'logIndex',
+  Origin = 'origin',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Recipient = 'recipient',
+  Sender = 'sender',
+  SqrtPriceX96 = 'sqrtPriceX96',
+  Tick = 'tick',
+  Timestamp = 'timestamp',
+  Token0 = 'token0',
+  Token0Decimals = 'token0__decimals',
+  Token0DerivedEth = 'token0__derivedETH',
+  Token0FeesUsd = 'token0__feesUSD',
+  Token0Id = 'token0__id',
+  Token0Name = 'token0__name',
+  Token0PoolCount = 'token0__poolCount',
+  Token0Symbol = 'token0__symbol',
+  Token0TotalSupply = 'token0__totalSupply',
+  Token0TotalValueLocked = 'token0__totalValueLocked',
+  Token0TotalValueLockedUsd = 'token0__totalValueLockedUSD',
+  Token0TotalValueLockedUsdUntracked = 'token0__totalValueLockedUSDUntracked',
+  Token0TxCount = 'token0__txCount',
+  Token0UntrackedVolumeUsd = 'token0__untrackedVolumeUSD',
+  Token0Volume = 'token0__volume',
+  Token0VolumeUsd = 'token0__volumeUSD',
+  Token1 = 'token1',
+  Token1Decimals = 'token1__decimals',
+  Token1DerivedEth = 'token1__derivedETH',
+  Token1FeesUsd = 'token1__feesUSD',
+  Token1Id = 'token1__id',
+  Token1Name = 'token1__name',
+  Token1PoolCount = 'token1__poolCount',
+  Token1Symbol = 'token1__symbol',
+  Token1TotalSupply = 'token1__totalSupply',
+  Token1TotalValueLocked = 'token1__totalValueLocked',
+  Token1TotalValueLockedUsd = 'token1__totalValueLockedUSD',
+  Token1TotalValueLockedUsdUntracked = 'token1__totalValueLockedUSDUntracked',
+  Token1TxCount = 'token1__txCount',
+  Token1UntrackedVolumeUsd = 'token1__untrackedVolumeUSD',
+  Token1Volume = 'token1__volume',
+  Token1VolumeUsd = 'token1__volumeUSD',
+  Transaction = 'transaction',
+  TransactionBlockNumber = 'transaction__blockNumber',
+  TransactionGasPrice = 'transaction__gasPrice',
+  TransactionGasUsed = 'transaction__gasUsed',
+  TransactionId = 'transaction__id',
+  TransactionTimestamp = 'transaction__timestamp'
+}
+
+export type Tick = {
+  __typename?: 'Tick';
+  collectedFeesToken0: Scalars['BigDecimal'];
+  collectedFeesToken1: Scalars['BigDecimal'];
+  collectedFeesUSD: Scalars['BigDecimal'];
+  createdAtBlockNumber: Scalars['BigInt'];
+  createdAtTimestamp: Scalars['BigInt'];
+  feeGrowthOutside0X128: Scalars['BigInt'];
+  feeGrowthOutside1X128: Scalars['BigInt'];
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidityGross: Scalars['BigInt'];
+  liquidityNet: Scalars['BigInt'];
+  liquidityProviderCount: Scalars['BigInt'];
+  pool: Pool;
+  poolAddress?: Maybe<Scalars['String']>;
+  price0: Scalars['BigDecimal'];
+  price1: Scalars['BigDecimal'];
+  tickIdx: Scalars['BigInt'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type TickDayData = {
+  __typename?: 'TickDayData';
+  date: Scalars['Int'];
+  feeGrowthOutside0X128: Scalars['BigInt'];
+  feeGrowthOutside1X128: Scalars['BigInt'];
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidityGross: Scalars['BigInt'];
+  liquidityNet: Scalars['BigInt'];
+  pool: Pool;
+  tick: Tick;
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type TickDayData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<TickDayData_Filter>>>;
+  date?: InputMaybe<Scalars['Int']>;
+  date_gt?: InputMaybe<Scalars['Int']>;
+  date_gte?: InputMaybe<Scalars['Int']>;
+  date_in?: InputMaybe<Array<Scalars['Int']>>;
+  date_lt?: InputMaybe<Scalars['Int']>;
+  date_lte?: InputMaybe<Scalars['Int']>;
+  date_not?: InputMaybe<Scalars['Int']>;
+  date_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  feeGrowthOutside0X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside0X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside1X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside1X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidityGross?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityGross_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<TickDayData_Filter>>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tick?: InputMaybe<Scalars['String']>;
+  tick_?: InputMaybe<Tick_Filter>;
+  tick_contains?: InputMaybe<Scalars['String']>;
+  tick_contains_nocase?: InputMaybe<Scalars['String']>;
+  tick_ends_with?: InputMaybe<Scalars['String']>;
+  tick_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_gt?: InputMaybe<Scalars['String']>;
+  tick_gte?: InputMaybe<Scalars['String']>;
+  tick_in?: InputMaybe<Array<Scalars['String']>>;
+  tick_lt?: InputMaybe<Scalars['String']>;
+  tick_lte?: InputMaybe<Scalars['String']>;
+  tick_not?: InputMaybe<Scalars['String']>;
+  tick_not_contains?: InputMaybe<Scalars['String']>;
+  tick_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  tick_not_ends_with?: InputMaybe<Scalars['String']>;
+  tick_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_not_in?: InputMaybe<Array<Scalars['String']>>;
+  tick_not_starts_with?: InputMaybe<Scalars['String']>;
+  tick_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_starts_with?: InputMaybe<Scalars['String']>;
+  tick_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum TickDayData_OrderBy {
+  Date = 'date',
+  FeeGrowthOutside0X128 = 'feeGrowthOutside0X128',
+  FeeGrowthOutside1X128 = 'feeGrowthOutside1X128',
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  LiquidityGross = 'liquidityGross',
+  LiquidityNet = 'liquidityNet',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Tick = 'tick',
+  TickCollectedFeesToken0 = 'tick__collectedFeesToken0',
+  TickCollectedFeesToken1 = 'tick__collectedFeesToken1',
+  TickCollectedFeesUsd = 'tick__collectedFeesUSD',
+  TickCreatedAtBlockNumber = 'tick__createdAtBlockNumber',
+  TickCreatedAtTimestamp = 'tick__createdAtTimestamp',
+  TickFeeGrowthOutside0X128 = 'tick__feeGrowthOutside0X128',
+  TickFeeGrowthOutside1X128 = 'tick__feeGrowthOutside1X128',
+  TickFeesUsd = 'tick__feesUSD',
+  TickId = 'tick__id',
+  TickLiquidityGross = 'tick__liquidityGross',
+  TickLiquidityNet = 'tick__liquidityNet',
+  TickLiquidityProviderCount = 'tick__liquidityProviderCount',
+  TickPoolAddress = 'tick__poolAddress',
+  TickPrice0 = 'tick__price0',
+  TickPrice1 = 'tick__price1',
+  TickTickIdx = 'tick__tickIdx',
+  TickUntrackedVolumeUsd = 'tick__untrackedVolumeUSD',
+  TickVolumeToken0 = 'tick__volumeToken0',
+  TickVolumeToken1 = 'tick__volumeToken1',
+  TickVolumeUsd = 'tick__volumeUSD',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type TickHourData = {
+  __typename?: 'TickHourData';
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  liquidityGross: Scalars['BigInt'];
+  liquidityNet: Scalars['BigInt'];
+  periodStartUnix: Scalars['Int'];
+  pool: Pool;
+  tick: Tick;
+  volumeToken0: Scalars['BigDecimal'];
+  volumeToken1: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type TickHourData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<TickHourData_Filter>>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidityGross?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityGross_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<TickHourData_Filter>>>;
+  periodStartUnix?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_in?: InputMaybe<Array<Scalars['Int']>>;
+  periodStartUnix_lt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_lte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  pool?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tick?: InputMaybe<Scalars['String']>;
+  tick_?: InputMaybe<Tick_Filter>;
+  tick_contains?: InputMaybe<Scalars['String']>;
+  tick_contains_nocase?: InputMaybe<Scalars['String']>;
+  tick_ends_with?: InputMaybe<Scalars['String']>;
+  tick_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_gt?: InputMaybe<Scalars['String']>;
+  tick_gte?: InputMaybe<Scalars['String']>;
+  tick_in?: InputMaybe<Array<Scalars['String']>>;
+  tick_lt?: InputMaybe<Scalars['String']>;
+  tick_lte?: InputMaybe<Scalars['String']>;
+  tick_not?: InputMaybe<Scalars['String']>;
+  tick_not_contains?: InputMaybe<Scalars['String']>;
+  tick_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  tick_not_ends_with?: InputMaybe<Scalars['String']>;
+  tick_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_not_in?: InputMaybe<Array<Scalars['String']>>;
+  tick_not_starts_with?: InputMaybe<Scalars['String']>;
+  tick_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tick_starts_with?: InputMaybe<Scalars['String']>;
+  tick_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum TickHourData_OrderBy {
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  LiquidityGross = 'liquidityGross',
+  LiquidityNet = 'liquidityNet',
+  PeriodStartUnix = 'periodStartUnix',
+  Pool = 'pool',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Tick = 'tick',
+  TickCollectedFeesToken0 = 'tick__collectedFeesToken0',
+  TickCollectedFeesToken1 = 'tick__collectedFeesToken1',
+  TickCollectedFeesUsd = 'tick__collectedFeesUSD',
+  TickCreatedAtBlockNumber = 'tick__createdAtBlockNumber',
+  TickCreatedAtTimestamp = 'tick__createdAtTimestamp',
+  TickFeeGrowthOutside0X128 = 'tick__feeGrowthOutside0X128',
+  TickFeeGrowthOutside1X128 = 'tick__feeGrowthOutside1X128',
+  TickFeesUsd = 'tick__feesUSD',
+  TickId = 'tick__id',
+  TickLiquidityGross = 'tick__liquidityGross',
+  TickLiquidityNet = 'tick__liquidityNet',
+  TickLiquidityProviderCount = 'tick__liquidityProviderCount',
+  TickPoolAddress = 'tick__poolAddress',
+  TickPrice0 = 'tick__price0',
+  TickPrice1 = 'tick__price1',
+  TickTickIdx = 'tick__tickIdx',
+  TickUntrackedVolumeUsd = 'tick__untrackedVolumeUSD',
+  TickVolumeToken0 = 'tick__volumeToken0',
+  TickVolumeToken1 = 'tick__volumeToken1',
+  TickVolumeUsd = 'tick__volumeUSD',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type Tick_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Tick_Filter>>>;
+  collectedFeesToken0?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  collectedFeesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  collectedFeesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  createdAtBlockNumber?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_gt?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_gte?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtBlockNumber_lt?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_lte?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_not?: InputMaybe<Scalars['BigInt']>;
+  createdAtBlockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtTimestamp?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  createdAtTimestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_not?: InputMaybe<Scalars['BigInt']>;
+  createdAtTimestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside0X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside0X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside0X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside1X128?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_gt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_gte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feeGrowthOutside1X128_lt?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_lte?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_not?: InputMaybe<Scalars['BigInt']>;
+  feeGrowthOutside1X128_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  liquidityGross?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityGross_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityGross_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityNet_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityNet_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityProviderCount?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_gt?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_gte?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  liquidityProviderCount_lt?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_lte?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_not?: InputMaybe<Scalars['BigInt']>;
+  liquidityProviderCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  or?: InputMaybe<Array<InputMaybe<Tick_Filter>>>;
+  pool?: InputMaybe<Scalars['String']>;
+  poolAddress?: InputMaybe<Scalars['String']>;
+  poolAddress_contains?: InputMaybe<Scalars['String']>;
+  poolAddress_contains_nocase?: InputMaybe<Scalars['String']>;
+  poolAddress_ends_with?: InputMaybe<Scalars['String']>;
+  poolAddress_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  poolAddress_gt?: InputMaybe<Scalars['String']>;
+  poolAddress_gte?: InputMaybe<Scalars['String']>;
+  poolAddress_in?: InputMaybe<Array<Scalars['String']>>;
+  poolAddress_lt?: InputMaybe<Scalars['String']>;
+  poolAddress_lte?: InputMaybe<Scalars['String']>;
+  poolAddress_not?: InputMaybe<Scalars['String']>;
+  poolAddress_not_contains?: InputMaybe<Scalars['String']>;
+  poolAddress_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  poolAddress_not_ends_with?: InputMaybe<Scalars['String']>;
+  poolAddress_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  poolAddress_not_in?: InputMaybe<Array<Scalars['String']>>;
+  poolAddress_not_starts_with?: InputMaybe<Scalars['String']>;
+  poolAddress_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  poolAddress_starts_with?: InputMaybe<Scalars['String']>;
+  poolAddress_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_?: InputMaybe<Pool_Filter>;
+  pool_contains?: InputMaybe<Scalars['String']>;
+  pool_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_ends_with?: InputMaybe<Scalars['String']>;
+  pool_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_gt?: InputMaybe<Scalars['String']>;
+  pool_gte?: InputMaybe<Scalars['String']>;
+  pool_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_lt?: InputMaybe<Scalars['String']>;
+  pool_lte?: InputMaybe<Scalars['String']>;
+  pool_not?: InputMaybe<Scalars['String']>;
+  pool_not_contains?: InputMaybe<Scalars['String']>;
+  pool_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with?: InputMaybe<Scalars['String']>;
+  pool_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_not_in?: InputMaybe<Array<Scalars['String']>>;
+  pool_not_starts_with?: InputMaybe<Scalars['String']>;
+  pool_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  pool_starts_with?: InputMaybe<Scalars['String']>;
+  pool_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  price0?: InputMaybe<Scalars['BigDecimal']>;
+  price0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  price0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  price0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  price0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  price0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  price0_not?: InputMaybe<Scalars['BigDecimal']>;
+  price0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  price1?: InputMaybe<Scalars['BigDecimal']>;
+  price1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  price1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  price1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  price1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  price1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  price1_not?: InputMaybe<Scalars['BigDecimal']>;
+  price1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tickIdx?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_gt?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_gte?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  tickIdx_lt?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_lte?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_not?: InputMaybe<Scalars['BigInt']>;
+  tickIdx_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken0_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken0_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeToken1_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeToken1_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum Tick_OrderBy {
+  CollectedFeesToken0 = 'collectedFeesToken0',
+  CollectedFeesToken1 = 'collectedFeesToken1',
+  CollectedFeesUsd = 'collectedFeesUSD',
+  CreatedAtBlockNumber = 'createdAtBlockNumber',
+  CreatedAtTimestamp = 'createdAtTimestamp',
+  FeeGrowthOutside0X128 = 'feeGrowthOutside0X128',
+  FeeGrowthOutside1X128 = 'feeGrowthOutside1X128',
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  LiquidityGross = 'liquidityGross',
+  LiquidityNet = 'liquidityNet',
+  LiquidityProviderCount = 'liquidityProviderCount',
+  Pool = 'pool',
+  PoolAddress = 'poolAddress',
+  PoolCollectedFeesToken0 = 'pool__collectedFeesToken0',
+  PoolCollectedFeesToken1 = 'pool__collectedFeesToken1',
+  PoolCollectedFeesUsd = 'pool__collectedFeesUSD',
+  PoolCreatedAtBlockNumber = 'pool__createdAtBlockNumber',
+  PoolCreatedAtTimestamp = 'pool__createdAtTimestamp',
+  PoolFeeGrowthGlobal0X128 = 'pool__feeGrowthGlobal0X128',
+  PoolFeeGrowthGlobal1X128 = 'pool__feeGrowthGlobal1X128',
+  PoolFeeTier = 'pool__feeTier',
+  PoolFeesUsd = 'pool__feesUSD',
+  PoolId = 'pool__id',
+  PoolLiquidity = 'pool__liquidity',
+  PoolLiquidityProviderCount = 'pool__liquidityProviderCount',
+  PoolObservationIndex = 'pool__observationIndex',
+  PoolSqrtPrice = 'pool__sqrtPrice',
+  PoolTick = 'pool__tick',
+  PoolToken0Price = 'pool__token0Price',
+  PoolToken1Price = 'pool__token1Price',
+  PoolTotalValueLockedEth = 'pool__totalValueLockedETH',
+  PoolTotalValueLockedToken0 = 'pool__totalValueLockedToken0',
+  PoolTotalValueLockedToken1 = 'pool__totalValueLockedToken1',
+  PoolTotalValueLockedUsd = 'pool__totalValueLockedUSD',
+  PoolTotalValueLockedUsdUntracked = 'pool__totalValueLockedUSDUntracked',
+  PoolTxCount = 'pool__txCount',
+  PoolUntrackedVolumeUsd = 'pool__untrackedVolumeUSD',
+  PoolVolumeToken0 = 'pool__volumeToken0',
+  PoolVolumeToken1 = 'pool__volumeToken1',
+  PoolVolumeUsd = 'pool__volumeUSD',
+  Price0 = 'price0',
+  Price1 = 'price1',
+  TickIdx = 'tickIdx',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD',
+  VolumeToken0 = 'volumeToken0',
+  VolumeToken1 = 'volumeToken1',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type Token = {
+  __typename?: 'Token';
+  decimals: Scalars['BigInt'];
+  derivedETH: Scalars['BigDecimal'];
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  name: Scalars['String'];
+  poolCount: Scalars['BigInt'];
+  symbol: Scalars['String'];
+  tokenDayData: Array<TokenDayData>;
+  totalSupply: Scalars['BigInt'];
+  totalValueLocked: Scalars['BigDecimal'];
+  totalValueLockedUSD: Scalars['BigDecimal'];
+  totalValueLockedUSDUntracked: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+  volume: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+  whitelistPools: Array<Pool>;
+};
+
+
+export type TokenTokenDayDataArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<TokenDayData_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<TokenDayData_Filter>;
+};
+
+
+export type TokenWhitelistPoolsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Pool_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Pool_Filter>;
+};
+
+export type TokenDayData = {
+  __typename?: 'TokenDayData';
+  close: Scalars['BigDecimal'];
+  date: Scalars['Int'];
+  feesUSD: Scalars['BigDecimal'];
+  high: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  low: Scalars['BigDecimal'];
+  open: Scalars['BigDecimal'];
+  priceUSD: Scalars['BigDecimal'];
+  token: Token;
+  totalValueLocked: Scalars['BigDecimal'];
+  totalValueLockedUSD: Scalars['BigDecimal'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+  volume: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type TokenDayData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<TokenDayData_Filter>>>;
+  close?: InputMaybe<Scalars['BigDecimal']>;
+  close_gt?: InputMaybe<Scalars['BigDecimal']>;
+  close_gte?: InputMaybe<Scalars['BigDecimal']>;
+  close_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close_lt?: InputMaybe<Scalars['BigDecimal']>;
+  close_lte?: InputMaybe<Scalars['BigDecimal']>;
+  close_not?: InputMaybe<Scalars['BigDecimal']>;
+  close_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  date?: InputMaybe<Scalars['Int']>;
+  date_gt?: InputMaybe<Scalars['Int']>;
+  date_gte?: InputMaybe<Scalars['Int']>;
+  date_in?: InputMaybe<Array<Scalars['Int']>>;
+  date_lt?: InputMaybe<Scalars['Int']>;
+  date_lte?: InputMaybe<Scalars['Int']>;
+  date_not?: InputMaybe<Scalars['Int']>;
+  date_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high?: InputMaybe<Scalars['BigDecimal']>;
+  high_gt?: InputMaybe<Scalars['BigDecimal']>;
+  high_gte?: InputMaybe<Scalars['BigDecimal']>;
+  high_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high_lt?: InputMaybe<Scalars['BigDecimal']>;
+  high_lte?: InputMaybe<Scalars['BigDecimal']>;
+  high_not?: InputMaybe<Scalars['BigDecimal']>;
+  high_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  low?: InputMaybe<Scalars['BigDecimal']>;
+  low_gt?: InputMaybe<Scalars['BigDecimal']>;
+  low_gte?: InputMaybe<Scalars['BigDecimal']>;
+  low_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low_lt?: InputMaybe<Scalars['BigDecimal']>;
+  low_lte?: InputMaybe<Scalars['BigDecimal']>;
+  low_not?: InputMaybe<Scalars['BigDecimal']>;
+  low_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open?: InputMaybe<Scalars['BigDecimal']>;
+  open_gt?: InputMaybe<Scalars['BigDecimal']>;
+  open_gte?: InputMaybe<Scalars['BigDecimal']>;
+  open_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open_lt?: InputMaybe<Scalars['BigDecimal']>;
+  open_lte?: InputMaybe<Scalars['BigDecimal']>;
+  open_not?: InputMaybe<Scalars['BigDecimal']>;
+  open_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  or?: InputMaybe<Array<InputMaybe<TokenDayData_Filter>>>;
+  priceUSD?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  priceUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token?: InputMaybe<Scalars['String']>;
+  token_?: InputMaybe<Token_Filter>;
+  token_contains?: InputMaybe<Scalars['String']>;
+  token_contains_nocase?: InputMaybe<Scalars['String']>;
+  token_ends_with?: InputMaybe<Scalars['String']>;
+  token_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token_gt?: InputMaybe<Scalars['String']>;
+  token_gte?: InputMaybe<Scalars['String']>;
+  token_in?: InputMaybe<Array<Scalars['String']>>;
+  token_lt?: InputMaybe<Scalars['String']>;
+  token_lte?: InputMaybe<Scalars['String']>;
+  token_not?: InputMaybe<Scalars['String']>;
+  token_not_contains?: InputMaybe<Scalars['String']>;
+  token_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token_not_ends_with?: InputMaybe<Scalars['String']>;
+  token_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token_not_starts_with?: InputMaybe<Scalars['String']>;
+  token_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token_starts_with?: InputMaybe<Scalars['String']>;
+  token_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  totalValueLocked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum TokenDayData_OrderBy {
+  Close = 'close',
+  Date = 'date',
+  FeesUsd = 'feesUSD',
+  High = 'high',
+  Id = 'id',
+  Low = 'low',
+  Open = 'open',
+  PriceUsd = 'priceUSD',
+  Token = 'token',
+  TokenDecimals = 'token__decimals',
+  TokenDerivedEth = 'token__derivedETH',
+  TokenFeesUsd = 'token__feesUSD',
+  TokenId = 'token__id',
+  TokenName = 'token__name',
+  TokenPoolCount = 'token__poolCount',
+  TokenSymbol = 'token__symbol',
+  TokenTotalSupply = 'token__totalSupply',
+  TokenTotalValueLocked = 'token__totalValueLocked',
+  TokenTotalValueLockedUsd = 'token__totalValueLockedUSD',
+  TokenTotalValueLockedUsdUntracked = 'token__totalValueLockedUSDUntracked',
+  TokenTxCount = 'token__txCount',
+  TokenUntrackedVolumeUsd = 'token__untrackedVolumeUSD',
+  TokenVolume = 'token__volume',
+  TokenVolumeUsd = 'token__volumeUSD',
+  TotalValueLocked = 'totalValueLocked',
+  TotalValueLockedUsd = 'totalValueLockedUSD',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD',
+  Volume = 'volume',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type TokenHourData = {
+  __typename?: 'TokenHourData';
+  close: Scalars['BigDecimal'];
+  feesUSD: Scalars['BigDecimal'];
+  high: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  low: Scalars['BigDecimal'];
+  open: Scalars['BigDecimal'];
+  periodStartUnix: Scalars['Int'];
+  priceUSD: Scalars['BigDecimal'];
+  token: Token;
+  totalValueLocked: Scalars['BigDecimal'];
+  totalValueLockedUSD: Scalars['BigDecimal'];
+  untrackedVolumeUSD: Scalars['BigDecimal'];
+  volume: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+};
+
+export type TokenHourData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<TokenHourData_Filter>>>;
+  close?: InputMaybe<Scalars['BigDecimal']>;
+  close_gt?: InputMaybe<Scalars['BigDecimal']>;
+  close_gte?: InputMaybe<Scalars['BigDecimal']>;
+  close_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  close_lt?: InputMaybe<Scalars['BigDecimal']>;
+  close_lte?: InputMaybe<Scalars['BigDecimal']>;
+  close_not?: InputMaybe<Scalars['BigDecimal']>;
+  close_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high?: InputMaybe<Scalars['BigDecimal']>;
+  high_gt?: InputMaybe<Scalars['BigDecimal']>;
+  high_gte?: InputMaybe<Scalars['BigDecimal']>;
+  high_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  high_lt?: InputMaybe<Scalars['BigDecimal']>;
+  high_lte?: InputMaybe<Scalars['BigDecimal']>;
+  high_not?: InputMaybe<Scalars['BigDecimal']>;
+  high_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  low?: InputMaybe<Scalars['BigDecimal']>;
+  low_gt?: InputMaybe<Scalars['BigDecimal']>;
+  low_gte?: InputMaybe<Scalars['BigDecimal']>;
+  low_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  low_lt?: InputMaybe<Scalars['BigDecimal']>;
+  low_lte?: InputMaybe<Scalars['BigDecimal']>;
+  low_not?: InputMaybe<Scalars['BigDecimal']>;
+  low_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open?: InputMaybe<Scalars['BigDecimal']>;
+  open_gt?: InputMaybe<Scalars['BigDecimal']>;
+  open_gte?: InputMaybe<Scalars['BigDecimal']>;
+  open_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  open_lt?: InputMaybe<Scalars['BigDecimal']>;
+  open_lte?: InputMaybe<Scalars['BigDecimal']>;
+  open_not?: InputMaybe<Scalars['BigDecimal']>;
+  open_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  or?: InputMaybe<Array<InputMaybe<TokenHourData_Filter>>>;
+  periodStartUnix?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_gte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_in?: InputMaybe<Array<Scalars['Int']>>;
+  periodStartUnix_lt?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_lte?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not?: InputMaybe<Scalars['Int']>;
+  periodStartUnix_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  priceUSD?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  priceUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  priceUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  token?: InputMaybe<Scalars['String']>;
+  token_?: InputMaybe<Token_Filter>;
+  token_contains?: InputMaybe<Scalars['String']>;
+  token_contains_nocase?: InputMaybe<Scalars['String']>;
+  token_ends_with?: InputMaybe<Scalars['String']>;
+  token_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token_gt?: InputMaybe<Scalars['String']>;
+  token_gte?: InputMaybe<Scalars['String']>;
+  token_in?: InputMaybe<Array<Scalars['String']>>;
+  token_lt?: InputMaybe<Scalars['String']>;
+  token_lte?: InputMaybe<Scalars['String']>;
+  token_not?: InputMaybe<Scalars['String']>;
+  token_not_contains?: InputMaybe<Scalars['String']>;
+  token_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  token_not_ends_with?: InputMaybe<Scalars['String']>;
+  token_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  token_not_in?: InputMaybe<Array<Scalars['String']>>;
+  token_not_starts_with?: InputMaybe<Scalars['String']>;
+  token_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  token_starts_with?: InputMaybe<Scalars['String']>;
+  token_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  totalValueLocked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum TokenHourData_OrderBy {
+  Close = 'close',
+  FeesUsd = 'feesUSD',
+  High = 'high',
+  Id = 'id',
+  Low = 'low',
+  Open = 'open',
+  PeriodStartUnix = 'periodStartUnix',
+  PriceUsd = 'priceUSD',
+  Token = 'token',
+  TokenDecimals = 'token__decimals',
+  TokenDerivedEth = 'token__derivedETH',
+  TokenFeesUsd = 'token__feesUSD',
+  TokenId = 'token__id',
+  TokenName = 'token__name',
+  TokenPoolCount = 'token__poolCount',
+  TokenSymbol = 'token__symbol',
+  TokenTotalSupply = 'token__totalSupply',
+  TokenTotalValueLocked = 'token__totalValueLocked',
+  TokenTotalValueLockedUsd = 'token__totalValueLockedUSD',
+  TokenTotalValueLockedUsdUntracked = 'token__totalValueLockedUSDUntracked',
+  TokenTxCount = 'token__txCount',
+  TokenUntrackedVolumeUsd = 'token__untrackedVolumeUSD',
+  TokenVolume = 'token__volume',
+  TokenVolumeUsd = 'token__volumeUSD',
+  TotalValueLocked = 'totalValueLocked',
+  TotalValueLockedUsd = 'totalValueLockedUSD',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD',
+  Volume = 'volume',
+  VolumeUsd = 'volumeUSD'
+}
+
+export type Token_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Token_Filter>>>;
+  decimals?: InputMaybe<Scalars['BigInt']>;
+  decimals_gt?: InputMaybe<Scalars['BigInt']>;
+  decimals_gte?: InputMaybe<Scalars['BigInt']>;
+  decimals_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  decimals_lt?: InputMaybe<Scalars['BigInt']>;
+  decimals_lte?: InputMaybe<Scalars['BigInt']>;
+  decimals_not?: InputMaybe<Scalars['BigInt']>;
+  decimals_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  derivedETH?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  derivedETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  derivedETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  name?: InputMaybe<Scalars['String']>;
+  name_contains?: InputMaybe<Scalars['String']>;
+  name_contains_nocase?: InputMaybe<Scalars['String']>;
+  name_ends_with?: InputMaybe<Scalars['String']>;
+  name_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  name_gt?: InputMaybe<Scalars['String']>;
+  name_gte?: InputMaybe<Scalars['String']>;
+  name_in?: InputMaybe<Array<Scalars['String']>>;
+  name_lt?: InputMaybe<Scalars['String']>;
+  name_lte?: InputMaybe<Scalars['String']>;
+  name_not?: InputMaybe<Scalars['String']>;
+  name_not_contains?: InputMaybe<Scalars['String']>;
+  name_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  name_not_ends_with?: InputMaybe<Scalars['String']>;
+  name_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  name_not_in?: InputMaybe<Array<Scalars['String']>>;
+  name_not_starts_with?: InputMaybe<Scalars['String']>;
+  name_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  name_starts_with?: InputMaybe<Scalars['String']>;
+  name_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  or?: InputMaybe<Array<InputMaybe<Token_Filter>>>;
+  poolCount?: InputMaybe<Scalars['BigInt']>;
+  poolCount_gt?: InputMaybe<Scalars['BigInt']>;
+  poolCount_gte?: InputMaybe<Scalars['BigInt']>;
+  poolCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  poolCount_lt?: InputMaybe<Scalars['BigInt']>;
+  poolCount_lte?: InputMaybe<Scalars['BigInt']>;
+  poolCount_not?: InputMaybe<Scalars['BigInt']>;
+  poolCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  symbol?: InputMaybe<Scalars['String']>;
+  symbol_contains?: InputMaybe<Scalars['String']>;
+  symbol_contains_nocase?: InputMaybe<Scalars['String']>;
+  symbol_ends_with?: InputMaybe<Scalars['String']>;
+  symbol_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_gt?: InputMaybe<Scalars['String']>;
+  symbol_gte?: InputMaybe<Scalars['String']>;
+  symbol_in?: InputMaybe<Array<Scalars['String']>>;
+  symbol_lt?: InputMaybe<Scalars['String']>;
+  symbol_lte?: InputMaybe<Scalars['String']>;
+  symbol_not?: InputMaybe<Scalars['String']>;
+  symbol_not_contains?: InputMaybe<Scalars['String']>;
+  symbol_not_contains_nocase?: InputMaybe<Scalars['String']>;
+  symbol_not_ends_with?: InputMaybe<Scalars['String']>;
+  symbol_not_ends_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_not_in?: InputMaybe<Array<Scalars['String']>>;
+  symbol_not_starts_with?: InputMaybe<Scalars['String']>;
+  symbol_not_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  symbol_starts_with?: InputMaybe<Scalars['String']>;
+  symbol_starts_with_nocase?: InputMaybe<Scalars['String']>;
+  tokenDayData_?: InputMaybe<TokenDayData_Filter>;
+  totalSupply?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_gt?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_gte?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  totalSupply_lt?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_lte?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_not?: InputMaybe<Scalars['BigInt']>;
+  totalSupply_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  totalValueLocked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSDUntracked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSDUntracked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLockedUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLockedUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  totalValueLocked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not?: InputMaybe<Scalars['BigDecimal']>;
+  totalValueLocked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  untrackedVolumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  untrackedVolumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  untrackedVolumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volume_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volume_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not?: InputMaybe<Scalars['BigDecimal']>;
+  volume_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  whitelistPools?: InputMaybe<Array<Scalars['String']>>;
+  whitelistPools_?: InputMaybe<Pool_Filter>;
+  whitelistPools_contains?: InputMaybe<Array<Scalars['String']>>;
+  whitelistPools_contains_nocase?: InputMaybe<Array<Scalars['String']>>;
+  whitelistPools_not?: InputMaybe<Array<Scalars['String']>>;
+  whitelistPools_not_contains?: InputMaybe<Array<Scalars['String']>>;
+  whitelistPools_not_contains_nocase?: InputMaybe<Array<Scalars['String']>>;
+};
+
+export enum Token_OrderBy {
+  Decimals = 'decimals',
+  DerivedEth = 'derivedETH',
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  Name = 'name',
+  PoolCount = 'poolCount',
+  Symbol = 'symbol',
+  TokenDayData = 'tokenDayData',
+  TotalSupply = 'totalSupply',
+  TotalValueLocked = 'totalValueLocked',
+  TotalValueLockedUsd = 'totalValueLockedUSD',
+  TotalValueLockedUsdUntracked = 'totalValueLockedUSDUntracked',
+  TxCount = 'txCount',
+  UntrackedVolumeUsd = 'untrackedVolumeUSD',
+  Volume = 'volume',
+  VolumeUsd = 'volumeUSD',
+  WhitelistPools = 'whitelistPools'
+}
+
+export type Transaction = {
+  __typename?: 'Transaction';
+  blockNumber: Scalars['BigInt'];
+  burns: Array<Maybe<Burn>>;
+  collects: Array<Maybe<Collect>>;
+  flashed: Array<Maybe<Flash>>;
+  gasPrice: Scalars['BigInt'];
+  gasUsed: Scalars['BigInt'];
+  id: Scalars['ID'];
+  mints: Array<Maybe<Mint>>;
+  swaps: Array<Maybe<Swap>>;
+  timestamp: Scalars['BigInt'];
+};
+
+
+export type TransactionBurnsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Burn_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Burn_Filter>;
+};
+
+
+export type TransactionCollectsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Collect_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Collect_Filter>;
+};
+
+
+export type TransactionFlashedArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Flash_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Flash_Filter>;
+};
+
+
+export type TransactionMintsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Mint_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Mint_Filter>;
+};
+
+
+export type TransactionSwapsArgs = {
+  first?: InputMaybe<Scalars['Int']>;
+  orderBy?: InputMaybe<Swap_OrderBy>;
+  orderDirection?: InputMaybe<OrderDirection>;
+  skip?: InputMaybe<Scalars['Int']>;
+  where?: InputMaybe<Swap_Filter>;
+};
+
+export type Transaction_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<Transaction_Filter>>>;
+  blockNumber?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_gt?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_gte?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  blockNumber_lt?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_lte?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_not?: InputMaybe<Scalars['BigInt']>;
+  blockNumber_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  burns_?: InputMaybe<Burn_Filter>;
+  collects_?: InputMaybe<Collect_Filter>;
+  flashed_?: InputMaybe<Flash_Filter>;
+  gasPrice?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_gt?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_gte?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  gasPrice_lt?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_lte?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_not?: InputMaybe<Scalars['BigInt']>;
+  gasPrice_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  gasUsed?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_gt?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_gte?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  gasUsed_lt?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_lte?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_not?: InputMaybe<Scalars['BigInt']>;
+  gasUsed_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  mints_?: InputMaybe<Mint_Filter>;
+  or?: InputMaybe<Array<InputMaybe<Transaction_Filter>>>;
+  swaps_?: InputMaybe<Swap_Filter>;
+  timestamp?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_gte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  timestamp_lt?: InputMaybe<Scalars['BigInt']>;
+  timestamp_lte?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not?: InputMaybe<Scalars['BigInt']>;
+  timestamp_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+};
+
+export enum Transaction_OrderBy {
+  BlockNumber = 'blockNumber',
+  Burns = 'burns',
+  Collects = 'collects',
+  Flashed = 'flashed',
+  GasPrice = 'gasPrice',
+  GasUsed = 'gasUsed',
+  Id = 'id',
+  Mints = 'mints',
+  Swaps = 'swaps',
+  Timestamp = 'timestamp'
+}
+
+export type UniswapDayData = {
+  __typename?: 'UniswapDayData';
+  date: Scalars['Int'];
+  feesUSD: Scalars['BigDecimal'];
+  id: Scalars['ID'];
+  tvlUSD: Scalars['BigDecimal'];
+  txCount: Scalars['BigInt'];
+  volumeETH: Scalars['BigDecimal'];
+  volumeUSD: Scalars['BigDecimal'];
+  volumeUSDUntracked: Scalars['BigDecimal'];
+};
+
+export type UniswapDayData_Filter = {
+  /** Filter for the block changed event. */
+  _change_block?: InputMaybe<BlockChangedFilter>;
+  and?: InputMaybe<Array<InputMaybe<UniswapDayData_Filter>>>;
+  date?: InputMaybe<Scalars['Int']>;
+  date_gt?: InputMaybe<Scalars['Int']>;
+  date_gte?: InputMaybe<Scalars['Int']>;
+  date_in?: InputMaybe<Array<Scalars['Int']>>;
+  date_lt?: InputMaybe<Scalars['Int']>;
+  date_lte?: InputMaybe<Scalars['Int']>;
+  date_not?: InputMaybe<Scalars['Int']>;
+  date_not_in?: InputMaybe<Array<Scalars['Int']>>;
+  feesUSD?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  feesUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  feesUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  id?: InputMaybe<Scalars['ID']>;
+  id_gt?: InputMaybe<Scalars['ID']>;
+  id_gte?: InputMaybe<Scalars['ID']>;
+  id_in?: InputMaybe<Array<Scalars['ID']>>;
+  id_lt?: InputMaybe<Scalars['ID']>;
+  id_lte?: InputMaybe<Scalars['ID']>;
+  id_not?: InputMaybe<Scalars['ID']>;
+  id_not_in?: InputMaybe<Array<Scalars['ID']>>;
+  or?: InputMaybe<Array<InputMaybe<UniswapDayData_Filter>>>;
+  tvlUSD?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  tvlUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  tvlUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  txCount?: InputMaybe<Scalars['BigInt']>;
+  txCount_gt?: InputMaybe<Scalars['BigInt']>;
+  txCount_gte?: InputMaybe<Scalars['BigInt']>;
+  txCount_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  txCount_lt?: InputMaybe<Scalars['BigInt']>;
+  txCount_lte?: InputMaybe<Scalars['BigInt']>;
+  txCount_not?: InputMaybe<Scalars['BigInt']>;
+  txCount_not_in?: InputMaybe<Array<Scalars['BigInt']>>;
+  volumeETH?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeETH_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeETH_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSDUntracked_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSDUntracked_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_gt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_gte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+  volumeUSD_lt?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_lte?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not?: InputMaybe<Scalars['BigDecimal']>;
+  volumeUSD_not_in?: InputMaybe<Array<Scalars['BigDecimal']>>;
+};
+
+export enum UniswapDayData_OrderBy {
+  Date = 'date',
+  FeesUsd = 'feesUSD',
+  Id = 'id',
+  TvlUsd = 'tvlUSD',
+  TxCount = 'txCount',
+  VolumeEth = 'volumeETH',
+  VolumeUsd = 'volumeUSD',
+  VolumeUsdUntracked = 'volumeUSDUntracked'
+}
+
+export type _Block_ = {
+  __typename?: '_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_ = {
+  __typename?: '_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 enum _SubgraphErrorPolicy_ {
+  /** Data will be returned even if the subgraph has indexing errors */
+  Allow = 'allow',
+  /** If the subgraph has indexing errors, data will be omitted. The default. */
+  Deny = 'deny'
+}
+
+export type AllV3TicksQueryVariables = Exact<{
+  poolAddress?: InputMaybe<Scalars['String']>;
+  skip: Scalars['Int'];
+}>;
+
+
+export type AllV3TicksQuery = { __typename?: 'Query', ticks: Array<{ __typename?: 'Tick', liquidityNet: any, price0: any, price1: any, tick: any }> };
+
+export type FeeTierDistributionQueryVariables = Exact<{
+  token0: Scalars['String'];
+  token1: Scalars['String'];
+}>;
+
+
+export type FeeTierDistributionQuery = { __typename?: 'Query', _meta?: { __typename?: '_Meta_', block: { __typename?: '_Block_', number: number } }, asToken0: Array<{ __typename?: 'Pool', feeTier: any, totalValueLockedToken0: any, totalValueLockedToken1: any }>, asToken1: Array<{ __typename?: 'Pool', feeTier: any, totalValueLockedToken0: any, totalValueLockedToken1: any }> };
+
+export type PoolDataQueryVariables = Exact<{
+  poolId?: InputMaybe<Array<Scalars['ID']> | Scalars['ID']>;
+  block?: InputMaybe<Block_Height>;
+}>;
+
+
+export type PoolDataQuery = { __typename?: 'Query', pools: Array<{ __typename?: 'Pool', id: string, feeTier: any, liquidity: any, sqrtPrice: any, tick?: any, token0Price: any, token1Price: any, volumeUSD: any, volumeToken0: any, volumeToken1: any, txCount: any, totalValueLockedToken0: any, totalValueLockedToken1: any, totalValueLockedUSD: any, token0: { __typename?: 'Token', id: string, symbol: string, name: string, decimals: any, derivedETH: any }, token1: { __typename?: 'Token', id: string, symbol: string, name: string, decimals: any, derivedETH: any } }>, bundles: Array<{ __typename?: 'Bundle', ethPriceUSD: any }> };
+
+
+export const AllV3TicksDocument = gql`
+    query AllV3Ticks($poolAddress: String, $skip: Int!) {
+  ticks(
+    first: 1000
+    skip: $skip
+    where: {poolAddress: $poolAddress}
+    orderBy: tickIdx
+  ) {
+    tick: tickIdx
+    liquidityNet
+    price0
+    price1
+  }
+}
+    `;
+
+/**
+ * __useAllV3TicksQuery__
+ *
+ * To run a query within a React component, call `useAllV3TicksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useAllV3TicksQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useAllV3TicksQuery({
+ *   variables: {
+ *      poolAddress: // value for 'poolAddress'
+ *      skip: // value for 'skip'
+ *   },
+ * });
+ */
+export function useAllV3TicksQuery(baseOptions: Apollo.QueryHookOptions<AllV3TicksQuery, AllV3TicksQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<AllV3TicksQuery, AllV3TicksQueryVariables>(AllV3TicksDocument, options);
+      }
+export function useAllV3TicksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<AllV3TicksQuery, AllV3TicksQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<AllV3TicksQuery, AllV3TicksQueryVariables>(AllV3TicksDocument, options);
+        }
+export type AllV3TicksQueryHookResult = ReturnType<typeof useAllV3TicksQuery>;
+export type AllV3TicksLazyQueryHookResult = ReturnType<typeof useAllV3TicksLazyQuery>;
+export type AllV3TicksQueryResult = Apollo.QueryResult<AllV3TicksQuery, AllV3TicksQueryVariables>;
+export const FeeTierDistributionDocument = gql`
+    query FeeTierDistribution($token0: String!, $token1: String!) {
+  _meta {
+    block {
+      number
+    }
+  }
+  asToken0: pools(
+    orderBy: totalValueLockedToken0
+    orderDirection: desc
+    where: {token0: $token0, token1: $token1}
+  ) {
+    feeTier
+    totalValueLockedToken0
+    totalValueLockedToken1
+  }
+  asToken1: pools(
+    orderBy: totalValueLockedToken0
+    orderDirection: desc
+    where: {token0: $token1, token1: $token0}
+  ) {
+    feeTier
+    totalValueLockedToken0
+    totalValueLockedToken1
+  }
+}
+    `;
+
+/**
+ * __useFeeTierDistributionQuery__
+ *
+ * To run a query within a React component, call `useFeeTierDistributionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFeeTierDistributionQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useFeeTierDistributionQuery({
+ *   variables: {
+ *      token0: // value for 'token0'
+ *      token1: // value for 'token1'
+ *   },
+ * });
+ */
+export function useFeeTierDistributionQuery(baseOptions: Apollo.QueryHookOptions<FeeTierDistributionQuery, FeeTierDistributionQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<FeeTierDistributionQuery, FeeTierDistributionQueryVariables>(FeeTierDistributionDocument, options);
+      }
+export function useFeeTierDistributionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<FeeTierDistributionQuery, FeeTierDistributionQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<FeeTierDistributionQuery, FeeTierDistributionQueryVariables>(FeeTierDistributionDocument, options);
+        }
+export type FeeTierDistributionQueryHookResult = ReturnType<typeof useFeeTierDistributionQuery>;
+export type FeeTierDistributionLazyQueryHookResult = ReturnType<typeof useFeeTierDistributionLazyQuery>;
+export type FeeTierDistributionQueryResult = Apollo.QueryResult<FeeTierDistributionQuery, FeeTierDistributionQueryVariables>;
+export const PoolDataDocument = gql`
+    query PoolData($poolId: [ID!], $block: Block_height = null) {
+  pools(
+    where: {id_in: $poolId}
+    block: $block
+    orderBy: totalValueLockedUSD
+    orderDirection: desc
+    subgraphError: allow
+  ) {
+    id
+    feeTier
+    liquidity
+    sqrtPrice
+    tick
+    token0 {
+      id
+      symbol
+      name
+      decimals
+      derivedETH
+    }
+    token1 {
+      id
+      symbol
+      name
+      decimals
+      derivedETH
+    }
+    token0Price
+    token1Price
+    volumeUSD
+    volumeToken0
+    volumeToken1
+    txCount
+    totalValueLockedToken0
+    totalValueLockedToken1
+    totalValueLockedUSD
+  }
+  bundles(where: {id: "1"}) {
+    ethPriceUSD
+  }
+}
+    `;
+
+/**
+ * __usePoolDataQuery__
+ *
+ * To run a query within a React component, call `usePoolDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `usePoolDataQuery` returns an object from Apollo Client that contains loading, error, and data properties
+ * you can use to render your UI.
+ *
+ * @param baseOptions options that will be passed into the query, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = usePoolDataQuery({
+ *   variables: {
+ *      poolId: // value for 'poolId'
+ *      block: // value for 'block'
+ *   },
+ * });
+ */
+export function usePoolDataQuery(baseOptions?: Apollo.QueryHookOptions<PoolDataQuery, PoolDataQueryVariables>) {
+        const options = {...defaultOptions, ...baseOptions}
+        return Apollo.useQuery<PoolDataQuery, PoolDataQueryVariables>(PoolDataDocument, options);
+      }
+export function usePoolDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<PoolDataQuery, PoolDataQueryVariables>) {
+          const options = {...defaultOptions, ...baseOptions}
+          return Apollo.useLazyQuery<PoolDataQuery, PoolDataQueryVariables>(PoolDataDocument, options);
+        }
+export type PoolDataQueryHookResult = ReturnType<typeof usePoolDataQuery>;
+export type PoolDataLazyQueryHookResult = ReturnType<typeof usePoolDataLazyQuery>;
+export type PoolDataQueryResult = Apollo.QueryResult<PoolDataQuery, PoolDataQueryVariables>;
\ No newline at end of file
diff --git a/src/utils/__generated__/validateTokenList.js b/src/utils/__generated__/validateTokenList.js
new file mode 100644
index 00000000000..d4adda56ccc
--- /dev/null
+++ b/src/utils/__generated__/validateTokenList.js
@@ -0,0 +1 @@
+"use strict";export const validate = validate10;export default validate10;const schema11 = {"$schema":"http://json-schema.org/draft-07/schema#","$id":"https://uniswap.org/tokenlist.schema.json","title":"Uniswap Token List","description":"Schema for lists of tokens compatible with the Uniswap Interface","definitions":{"Version":{"type":"object","description":"The version of the list, used in change detection","examples":[{"major":1,"minor":0,"patch":0}],"additionalProperties":false,"properties":{"major":{"type":"integer","description":"The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.","minimum":0,"examples":[1,2]},"minor":{"type":"integer","description":"The minor version of the list. Must be incremented when tokens are added to the list.","minimum":0,"examples":[0,1]},"patch":{"type":"integer","description":"The patch version of the list. Must be incremented for any changes to the list.","minimum":0,"examples":[0,1]}},"required":["major","minor","patch"]},"TagIdentifier":{"type":"string","description":"The unique identifier of a tag","minLength":1,"maxLength":10,"pattern":"^[\\w]+$","examples":["compound","stablecoin"]},"ExtensionIdentifier":{"type":"string","description":"The name of a token extension property","minLength":1,"maxLength":40,"pattern":"^[\\w]+$","examples":["color","is_fee_on_transfer","aliases"]},"ExtensionMap":{"type":"object","description":"An object containing any arbitrary or vendor-specific token metadata","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValue"},"examples":[{"color":"#000000","is_verified_by_me":true},{"x-bridged-addresses-by-chain":{"1":{"bridgeAddress":"0x4200000000000000000000000000000000000010","tokenAddress":"0x4200000000000000000000000000000000000010"}}}]},"ExtensionPrimitiveValue":{"anyOf":[{"type":"string","minLength":1,"maxLength":42,"examples":["#00000"]},{"type":"boolean","examples":[true]},{"type":"number","examples":[15]},{"type":"null"}]},"ExtensionValue":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner0"}}]},"ExtensionValueInner0":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner1"}}]},"ExtensionValueInner1":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"}]},"TagDefinition":{"type":"object","description":"Definition of a tag that can be associated with a token via its identifier","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the tag","pattern":"^[ \\w]+$","minLength":1,"maxLength":20},"description":{"type":"string","description":"A user-friendly description of the tag","pattern":"^[ \\w\\.,:]+$","minLength":1,"maxLength":200}},"required":["name","description"],"examples":[{"name":"Stablecoin","description":"A token with value pegged to another asset"}]},"TokenInfo":{"type":"object","description":"Metadata for a single token in a token list","additionalProperties":false,"properties":{"chainId":{"type":"integer","description":"The chain ID of the Ethereum network where this token is deployed","minimum":1,"examples":[1,42]},"address":{"type":"string","description":"The checksummed address of the token on the specified chain ID","pattern":"^0x[a-fA-F0-9]{40}$","examples":["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]},"decimals":{"type":"integer","description":"The number of decimals for the token balance","minimum":0,"maximum":255,"examples":[18]},"name":{"type":"string","description":"The name of the token","minLength":0,"maxLength":40,"anyOf":[{"const":""},{"pattern":"^[ \\S+]+$"}],"examples":["USD Coin"]},"symbol":{"type":"string","description":"The symbol for the token","minLength":0,"maxLength":20,"anyOf":[{"const":""},{"pattern":"^\\S+$"}],"examples":["USDC"]},"logoURI":{"type":"string","description":"A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]},"tags":{"type":"array","description":"An array of tag identifiers associated with the token; tags are defined at the list level","items":{"$ref":"#/definitions/TagIdentifier"},"maxItems":10,"examples":["stablecoin","compound"]},"extensions":{"$ref":"#/definitions/ExtensionMap"}},"required":["chainId","address","decimals","name","symbol"]}},"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the token list","minLength":1,"maxLength":30,"pattern":"^[\\w ]+$","examples":["My Token List"]},"timestamp":{"type":"string","format":"date-time","description":"The timestamp of this list version; i.e. when this immutable version of the list was created"},"version":{"$ref":"#/definitions/Version"},"tokens":{"type":"array","description":"The list of tokens included in the list","items":{"$ref":"#/definitions/TokenInfo"},"minItems":1,"maxItems":10000},"tokenMap":{"type":"object","description":"A mapping of key 'chainId_tokenAddress' to its corresponding token object","minProperties":1,"maxProperties":10000,"propertyNames":{"type":"string"},"additionalProperties":{"$ref":"#/definitions/TokenInfo"},"examples":[{"4_0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984":{"name":"Uniswap","address":"0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984","symbol":"UNI","decimals":18,"chainId":4,"logoURI":"ipfs://QmXttGpZrECX5qCyXbBQiqgQNytVGeZW5Anewvh2jc4psg"}}]},"keywords":{"type":"array","description":"Keywords associated with the contents of the list; may be used in list discoverability","items":{"type":"string","description":"A keyword to describe the contents of the list","minLength":1,"maxLength":20,"pattern":"^[\\w ]+$","examples":["compound","lending","personal tokens"]},"maxItems":20,"uniqueItems":true},"tags":{"type":"object","description":"A mapping of tag identifiers to their name and description","propertyNames":{"$ref":"#/definitions/TagIdentifier"},"additionalProperties":{"$ref":"#/definitions/TagDefinition"},"maxProperties":20,"examples":[{"stablecoin":{"name":"Stablecoin","description":"A token with value pegged to another asset"}}]},"logoURI":{"type":"string","description":"A URI for the logo of the token list; prefer SVG or PNG of size 256x256","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]}},"required":["name","timestamp","version","tokens"]};const schema12 = {"type":"object","description":"The version of the list, used in change detection","examples":[{"major":1,"minor":0,"patch":0}],"additionalProperties":false,"properties":{"major":{"type":"integer","description":"The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.","minimum":0,"examples":[1,2]},"minor":{"type":"integer","description":"The minor version of the list. Must be incremented when tokens are added to the list.","minimum":0,"examples":[0,1]},"patch":{"type":"integer","description":"The patch version of the list. Must be incremented for any changes to the list.","minimum":0,"examples":[0,1]}},"required":["major","minor","patch"]};const schema14 = {"type":"string","description":"The unique identifier of a tag","minLength":1,"maxLength":10,"pattern":"^[\\w]+$","examples":["compound","stablecoin"]};const schema26 = {"type":"object","description":"Definition of a tag that can be associated with a token via its identifier","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the tag","pattern":"^[ \\w]+$","minLength":1,"maxLength":20},"description":{"type":"string","description":"A user-friendly description of the tag","pattern":"^[ \\w\\.,:]+$","minLength":1,"maxLength":200}},"required":["name","description"],"examples":[{"name":"Stablecoin","description":"A token with value pegged to another asset"}]};const func2 = require("ajv/dist/runtime/ucs2length").default;const pattern0 = new RegExp("^[\\w ]+$", "u");const pattern4 = new RegExp("^[\\w]+$", "u");const pattern10 = new RegExp("^[ \\w]+$", "u");const pattern11 = new RegExp("^[ \\w\\.,:]+$", "u");const formats0 = require("ajv-formats/dist/formats").fullFormats["date-time"];const formats2 = require("ajv-formats/dist/formats").fullFormats.uri;const schema13 = {"type":"object","description":"Metadata for a single token in a token list","additionalProperties":false,"properties":{"chainId":{"type":"integer","description":"The chain ID of the Ethereum network where this token is deployed","minimum":1,"examples":[1,42]},"address":{"type":"string","description":"The checksummed address of the token on the specified chain ID","pattern":"^0x[a-fA-F0-9]{40}$","examples":["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]},"decimals":{"type":"integer","description":"The number of decimals for the token balance","minimum":0,"maximum":255,"examples":[18]},"name":{"type":"string","description":"The name of the token","minLength":0,"maxLength":40,"anyOf":[{"const":""},{"pattern":"^[ \\S+]+$"}],"examples":["USD Coin"]},"symbol":{"type":"string","description":"The symbol for the token","minLength":0,"maxLength":20,"anyOf":[{"const":""},{"pattern":"^\\S+$"}],"examples":["USDC"]},"logoURI":{"type":"string","description":"A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]},"tags":{"type":"array","description":"An array of tag identifiers associated with the token; tags are defined at the list level","items":{"$ref":"#/definitions/TagIdentifier"},"maxItems":10,"examples":["stablecoin","compound"]},"extensions":{"$ref":"#/definitions/ExtensionMap"}},"required":["chainId","address","decimals","name","symbol"]};const pattern1 = new RegExp("^0x[a-fA-F0-9]{40}$", "u");const pattern2 = new RegExp("^[ \\S+]+$", "u");const pattern3 = new RegExp("^\\S+$", "u");const schema15 = {"type":"object","description":"An object containing any arbitrary or vendor-specific token metadata","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValue"},"examples":[{"color":"#000000","is_verified_by_me":true},{"x-bridged-addresses-by-chain":{"1":{"bridgeAddress":"0x4200000000000000000000000000000000000010","tokenAddress":"0x4200000000000000000000000000000000000010"}}}]};const schema16 = {"type":"string","description":"The name of a token extension property","minLength":1,"maxLength":40,"pattern":"^[\\w]+$","examples":["color","is_fee_on_transfer","aliases"]};const schema17 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner0"}}]};const schema18 = {"anyOf":[{"type":"string","minLength":1,"maxLength":42,"examples":["#00000"]},{"type":"boolean","examples":[true]},{"type":"number","examples":[15]},{"type":"null"}]};const schema20 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner1"}}]};const schema23 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"}]};function validate15(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const err7 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;validate15.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate15.errors = vErrors;return errors === 0;}function validate14(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const _errs12 = errors;if(errors === _errs12){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){const err7 = {instancePath,schemaPath:"#/anyOf/1/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;}else {for(const key0 in data){const _errs14 = errors;const _errs15 = errors;if(errors === _errs15){if(typeof key0 === "string"){if(func2(key0) > 40){const err8 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err8];}else {vErrors.push(err8);}errors++;}else {if(func2(key0) < 1){const err9 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err9];}else {vErrors.push(err9);}errors++;}else {if(!pattern4.test(key0)){const err10 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err10];}else {vErrors.push(err10);}errors++;}}}}else {const err11 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err11];}else {vErrors.push(err11);}errors++;}}var valid3 = _errs14 === errors;if(!valid3){const err12 = {instancePath,schemaPath:"#/anyOf/1/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err12];}else {vErrors.push(err12);}errors++;break;}}if(valid3){for(const key1 in data){const _errs18 = errors;if(!(validate15(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate15.errors : vErrors.concat(validate15.errors);errors = vErrors.length;}var valid5 = _errs18 === errors;if(!valid5){break;}}}}}else {const err13 = {instancePath,schemaPath:"#/anyOf/1/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err13];}else {vErrors.push(err13);}errors++;}}var _valid0 = _errs12 === errors;valid0 = valid0 || _valid0;}if(!valid0){const err14 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err14];}else {vErrors.push(err14);}errors++;validate14.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate14.errors = vErrors;return errors === 0;}function validate13(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const _errs12 = errors;if(errors === _errs12){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){const err7 = {instancePath,schemaPath:"#/anyOf/1/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;}else {for(const key0 in data){const _errs14 = errors;const _errs15 = errors;if(errors === _errs15){if(typeof key0 === "string"){if(func2(key0) > 40){const err8 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err8];}else {vErrors.push(err8);}errors++;}else {if(func2(key0) < 1){const err9 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err9];}else {vErrors.push(err9);}errors++;}else {if(!pattern4.test(key0)){const err10 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err10];}else {vErrors.push(err10);}errors++;}}}}else {const err11 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err11];}else {vErrors.push(err11);}errors++;}}var valid3 = _errs14 === errors;if(!valid3){const err12 = {instancePath,schemaPath:"#/anyOf/1/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err12];}else {vErrors.push(err12);}errors++;break;}}if(valid3){for(const key1 in data){const _errs18 = errors;if(!(validate14(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);errors = vErrors.length;}var valid5 = _errs18 === errors;if(!valid5){break;}}}}}else {const err13 = {instancePath,schemaPath:"#/anyOf/1/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err13];}else {vErrors.push(err13);}errors++;}}var _valid0 = _errs12 === errors;valid0 = valid0 || _valid0;}if(!valid0){const err14 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err14];}else {vErrors.push(err14);}errors++;validate13.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate13.errors = vErrors;return errors === 0;}function validate12(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){validate12.errors = [{instancePath,schemaPath:"#/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"}];return false;}else {for(const key0 in data){const _errs1 = errors;const _errs2 = errors;if(errors === _errs2){if(typeof key0 === "string"){if(func2(key0) > 40){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(key0) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}else {if(!pattern4.test(key0)){const err2 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}}}else {const err3 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}}var valid0 = _errs1 === errors;if(!valid0){const err4 = {instancePath,schemaPath:"#/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;validate12.errors = vErrors;return false;break;}}if(valid0){for(const key1 in data){const _errs5 = errors;if(!(validate13(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);errors = vErrors.length;}var valid2 = _errs5 === errors;if(!valid2){break;}}}}}else {validate12.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate12.errors = vErrors;return errors === 0;}function validate11(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){let missing0;if((((((data.chainId === undefined) && (missing0 = "chainId")) || ((data.address === undefined) && (missing0 = "address"))) || ((data.decimals === undefined) && (missing0 = "decimals"))) || ((data.name === undefined) && (missing0 = "name"))) || ((data.symbol === undefined) && (missing0 = "symbol"))){validate11.errors = [{instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: missing0},message:"must have required property '"+missing0+"'"}];return false;}else {const _errs1 = errors;for(const key0 in data){if(!((((((((key0 === "chainId") || (key0 === "address")) || (key0 === "decimals")) || (key0 === "name")) || (key0 === "symbol")) || (key0 === "logoURI")) || (key0 === "tags")) || (key0 === "extensions"))){validate11.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.chainId !== undefined){let data0 = data.chainId;const _errs2 = errors;if(!(((typeof data0 == "number") && (!(data0 % 1) && !isNaN(data0))) && (isFinite(data0)))){validate11.errors = [{instancePath:instancePath+"/chainId",schemaPath:"#/properties/chainId/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs2){if((typeof data0 == "number") && (isFinite(data0))){if(data0 < 1 || isNaN(data0)){validate11.errors = [{instancePath:instancePath+"/chainId",schemaPath:"#/properties/chainId/minimum",keyword:"minimum",params:{comparison: ">=", limit: 1},message:"must be >= 1"}];return false;}}}var valid0 = _errs2 === errors;}else {var valid0 = true;}if(valid0){if(data.address !== undefined){let data1 = data.address;const _errs4 = errors;if(errors === _errs4){if(typeof data1 === "string"){if(!pattern1.test(data1)){validate11.errors = [{instancePath:instancePath+"/address",schemaPath:"#/properties/address/pattern",keyword:"pattern",params:{pattern: "^0x[a-fA-F0-9]{40}$"},message:"must match pattern \""+"^0x[a-fA-F0-9]{40}$"+"\""}];return false;}}else {validate11.errors = [{instancePath:instancePath+"/address",schemaPath:"#/properties/address/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs4 === errors;}else {var valid0 = true;}if(valid0){if(data.decimals !== undefined){let data2 = data.decimals;const _errs6 = errors;if(!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs6){if((typeof data2 == "number") && (isFinite(data2))){if(data2 > 255 || isNaN(data2)){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/maximum",keyword:"maximum",params:{comparison: "<=", limit: 255},message:"must be <= 255"}];return false;}else {if(data2 < 0 || isNaN(data2)){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}}var valid0 = _errs6 === errors;}else {var valid0 = true;}if(valid0){if(data.name !== undefined){let data3 = data.name;const _errs8 = errors;const _errs10 = errors;let valid1 = false;const _errs11 = errors;if("" !== data3){const err0 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf/0/const",keyword:"const",params:{allowedValue: ""},message:"must be equal to constant"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}var _valid0 = _errs11 === errors;valid1 = valid1 || _valid0;if(!valid1){const _errs12 = errors;if(typeof data3 === "string"){if(!pattern2.test(data3)){const err1 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf/1/pattern",keyword:"pattern",params:{pattern: "^[ \\S+]+$"},message:"must match pattern \""+"^[ \\S+]+$"+"\""};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}var _valid0 = _errs12 === errors;valid1 = valid1 || _valid0;}if(!valid1){const err2 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;validate11.errors = vErrors;return false;}else {errors = _errs10;if(vErrors !== null){if(_errs10){vErrors.length = _errs10;}else {vErrors = null;}}}if(errors === _errs8){if(typeof data3 === "string"){if(func2(data3) > 40){validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters"}];return false;}else {if(func2(data3) < 0){validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/minLength",keyword:"minLength",params:{limit: 0},message:"must NOT have fewer than 0 characters"}];return false;}}}else {validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs8 === errors;}else {var valid0 = true;}if(valid0){if(data.symbol !== undefined){let data4 = data.symbol;const _errs13 = errors;const _errs15 = errors;let valid2 = false;const _errs16 = errors;if("" !== data4){const err3 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf/0/const",keyword:"const",params:{allowedValue: ""},message:"must be equal to constant"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs16 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs17 = errors;if(typeof data4 === "string"){if(!pattern3.test(data4)){const err4 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf/1/pattern",keyword:"pattern",params:{pattern: "^\\S+$"},message:"must match pattern \""+"^\\S+$"+"\""};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}}var _valid1 = _errs17 === errors;valid2 = valid2 || _valid1;}if(!valid2){const err5 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;validate11.errors = vErrors;return false;}else {errors = _errs15;if(vErrors !== null){if(_errs15){vErrors.length = _errs15;}else {vErrors = null;}}}if(errors === _errs13){if(typeof data4 === "string"){if(func2(data4) > 20){validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data4) < 0){validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/minLength",keyword:"minLength",params:{limit: 0},message:"must NOT have fewer than 0 characters"}];return false;}}}else {validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs13 === errors;}else {var valid0 = true;}if(valid0){if(data.logoURI !== undefined){let data5 = data.logoURI;const _errs18 = errors;if(errors === _errs18){if(errors === _errs18){if(typeof data5 === "string"){if(!(formats2(data5))){validate11.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""}];return false;}}else {validate11.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs18 === errors;}else {var valid0 = true;}if(valid0){if(data.tags !== undefined){let data6 = data.tags;const _errs20 = errors;if(errors === _errs20){if(Array.isArray(data6)){if(data6.length > 10){validate11.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/maxItems",keyword:"maxItems",params:{limit: 10},message:"must NOT have more than 10 items"}];return false;}else {var valid3 = true;const len0 = data6.length;for(let i0=0; i0<len0; i0++){let data7 = data6[i0];const _errs22 = errors;const _errs23 = errors;if(errors === _errs23){if(typeof data7 === "string"){if(func2(data7) > 10){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/maxLength",keyword:"maxLength",params:{limit: 10},message:"must NOT have more than 10 characters"}];return false;}else {if(func2(data7) < 1){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern4.test(data7)){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\""}];return false;}}}}else {validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid3 = _errs22 === errors;if(!valid3){break;}}}}else {validate11.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs20 === errors;}else {var valid0 = true;}if(valid0){if(data.extensions !== undefined){const _errs25 = errors;if(!(validate12(data.extensions, {instancePath:instancePath+"/extensions",parentData:data,parentDataProperty:"extensions",rootData}))){vErrors = vErrors === null ? validate12.errors : vErrors.concat(validate12.errors);errors = vErrors.length;}var valid0 = _errs25 === errors;}else {var valid0 = true;}}}}}}}}}}}else {validate11.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate11.errors = vErrors;return errors === 0;}function validate10(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){/*# sourceURL="https://uniswap.org/tokenlist.schema.json" */;let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){let missing0;if(((((data.name === undefined) && (missing0 = "name")) || ((data.timestamp === undefined) && (missing0 = "timestamp"))) || ((data.version === undefined) && (missing0 = "version"))) || ((data.tokens === undefined) && (missing0 = "tokens"))){validate10.errors = [{instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: missing0},message:"must have required property '"+missing0+"'"}];return false;}else {const _errs1 = errors;for(const key0 in data){if(!((((((((key0 === "name") || (key0 === "timestamp")) || (key0 === "version")) || (key0 === "tokens")) || (key0 === "tokenMap")) || (key0 === "keywords")) || (key0 === "tags")) || (key0 === "logoURI"))){validate10.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.name !== undefined){let data0 = data.name;const _errs2 = errors;if(errors === _errs2){if(typeof data0 === "string"){if(func2(data0) > 30){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/maxLength",keyword:"maxLength",params:{limit: 30},message:"must NOT have more than 30 characters"}];return false;}else {if(func2(data0) < 1){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern0.test(data0)){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/pattern",keyword:"pattern",params:{pattern: "^[\\w ]+$"},message:"must match pattern \""+"^[\\w ]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs2 === errors;}else {var valid0 = true;}if(valid0){if(data.timestamp !== undefined){let data1 = data.timestamp;const _errs4 = errors;if(errors === _errs4){if(errors === _errs4){if(typeof data1 === "string"){if(!(formats0.validate(data1))){validate10.errors = [{instancePath:instancePath+"/timestamp",schemaPath:"#/properties/timestamp/format",keyword:"format",params:{format: "date-time"},message:"must match format \""+"date-time"+"\""}];return false;}}else {validate10.errors = [{instancePath:instancePath+"/timestamp",schemaPath:"#/properties/timestamp/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs4 === errors;}else {var valid0 = true;}if(valid0){if(data.version !== undefined){let data2 = data.version;const _errs6 = errors;const _errs7 = errors;if(errors === _errs7){if(data2 && typeof data2 == "object" && !Array.isArray(data2)){let missing1;if((((data2.major === undefined) && (missing1 = "major")) || ((data2.minor === undefined) && (missing1 = "minor"))) || ((data2.patch === undefined) && (missing1 = "patch"))){validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/required",keyword:"required",params:{missingProperty: missing1},message:"must have required property '"+missing1+"'"}];return false;}else {const _errs9 = errors;for(const key1 in data2){if(!(((key1 === "major") || (key1 === "minor")) || (key1 === "patch"))){validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"}];return false;break;}}if(_errs9 === errors){if(data2.major !== undefined){let data3 = data2.major;const _errs10 = errors;if(!(((typeof data3 == "number") && (!(data3 % 1) && !isNaN(data3))) && (isFinite(data3)))){validate10.errors = [{instancePath:instancePath+"/version/major",schemaPath:"#/definitions/Version/properties/major/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs10){if((typeof data3 == "number") && (isFinite(data3))){if(data3 < 0 || isNaN(data3)){validate10.errors = [{instancePath:instancePath+"/version/major",schemaPath:"#/definitions/Version/properties/major/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs10 === errors;}else {var valid2 = true;}if(valid2){if(data2.minor !== undefined){let data4 = data2.minor;const _errs12 = errors;if(!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))){validate10.errors = [{instancePath:instancePath+"/version/minor",schemaPath:"#/definitions/Version/properties/minor/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs12){if((typeof data4 == "number") && (isFinite(data4))){if(data4 < 0 || isNaN(data4)){validate10.errors = [{instancePath:instancePath+"/version/minor",schemaPath:"#/definitions/Version/properties/minor/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs12 === errors;}else {var valid2 = true;}if(valid2){if(data2.patch !== undefined){let data5 = data2.patch;const _errs14 = errors;if(!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))){validate10.errors = [{instancePath:instancePath+"/version/patch",schemaPath:"#/definitions/Version/properties/patch/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs14){if((typeof data5 == "number") && (isFinite(data5))){if(data5 < 0 || isNaN(data5)){validate10.errors = [{instancePath:instancePath+"/version/patch",schemaPath:"#/definitions/Version/properties/patch/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs14 === errors;}else {var valid2 = true;}}}}}}else {validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs6 === errors;}else {var valid0 = true;}if(valid0){if(data.tokens !== undefined){let data6 = data.tokens;const _errs16 = errors;if(errors === _errs16){if(Array.isArray(data6)){if(data6.length > 10000){validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/maxItems",keyword:"maxItems",params:{limit: 10000},message:"must NOT have more than 10000 items"}];return false;}else {if(data6.length < 1){validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/minItems",keyword:"minItems",params:{limit: 1},message:"must NOT have fewer than 1 items"}];return false;}else {var valid3 = true;const len0 = data6.length;for(let i0=0; i0<len0; i0++){const _errs18 = errors;if(!(validate11(data6[i0], {instancePath:instancePath+"/tokens/" + i0,parentData:data6,parentDataProperty:i0,rootData}))){vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);errors = vErrors.length;}var valid3 = _errs18 === errors;if(!valid3){break;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs16 === errors;}else {var valid0 = true;}if(valid0){if(data.tokenMap !== undefined){let data8 = data.tokenMap;const _errs19 = errors;if(errors === _errs19){if(data8 && typeof data8 == "object" && !Array.isArray(data8)){if(Object.keys(data8).length > 10000){validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/maxProperties",keyword:"maxProperties",params:{limit: 10000},message:"must NOT have more than 10000 properties"}];return false;}else {if(Object.keys(data8).length < 1){validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/minProperties",keyword:"minProperties",params:{limit: 1},message:"must NOT have fewer than 1 properties"}];return false;}else {for(const key2 in data8){const _errs21 = errors;if(typeof key2 !== "string"){const err0 = {instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/propertyNames/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key2};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}var valid4 = _errs21 === errors;if(!valid4){const err1 = {instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/propertyNames",keyword:"propertyNames",params:{propertyName: key2},message:"property name must be valid"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;validate10.errors = vErrors;return false;break;}}if(valid4){for(const key3 in data8){const _errs24 = errors;if(!(validate11(data8[key3], {instancePath:instancePath+"/tokenMap/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data8,parentDataProperty:key3,rootData}))){vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);errors = vErrors.length;}var valid5 = _errs24 === errors;if(!valid5){break;}}}}}}else {validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs19 === errors;}else {var valid0 = true;}if(valid0){if(data.keywords !== undefined){let data10 = data.keywords;const _errs25 = errors;if(errors === _errs25){if(Array.isArray(data10)){if(data10.length > 20){validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/maxItems",keyword:"maxItems",params:{limit: 20},message:"must NOT have more than 20 items"}];return false;}else {var valid6 = true;const len1 = data10.length;for(let i1=0; i1<len1; i1++){let data11 = data10[i1];const _errs27 = errors;if(errors === _errs27){if(typeof data11 === "string"){if(func2(data11) > 20){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data11) < 1){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern0.test(data11)){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/pattern",keyword:"pattern",params:{pattern: "^[\\w ]+$"},message:"must match pattern \""+"^[\\w ]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid6 = _errs27 === errors;if(!valid6){break;}}if(valid6){let i2 = data10.length;let j0;if(i2 > 1){const indices0 = {};for(;i2--;){let item0 = data10[i2];if(typeof item0 !== "string"){continue;}if(typeof indices0[item0] == "number"){j0 = indices0[item0];validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/uniqueItems",keyword:"uniqueItems",params:{i: i2, j: j0},message:"must NOT have duplicate items (items ## "+j0+" and "+i2+" are identical)"}];return false;break;}indices0[item0] = i2;}}}}}else {validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs25 === errors;}else {var valid0 = true;}if(valid0){if(data.tags !== undefined){let data12 = data.tags;const _errs29 = errors;if(errors === _errs29){if(data12 && typeof data12 == "object" && !Array.isArray(data12)){if(Object.keys(data12).length > 20){validate10.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/maxProperties",keyword:"maxProperties",params:{limit: 20},message:"must NOT have more than 20 properties"}];return false;}else {for(const key4 in data12){const _errs31 = errors;const _errs32 = errors;if(errors === _errs32){if(typeof key4 === "string"){if(func2(key4) > 10){const err2 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/maxLength",keyword:"maxLength",params:{limit: 10},message:"must NOT have more than 10 characters",propertyName:key4};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}else {if(func2(key4) < 1){const err3 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key4};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}else {if(!pattern4.test(key4)){const err4 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key4};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}}}}else {const err5 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key4};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}}var valid8 = _errs31 === errors;if(!valid8){const err6 = {instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/propertyNames",keyword:"propertyNames",params:{propertyName: key4},message:"property name must be valid"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;validate10.errors = vErrors;return false;break;}}if(valid8){for(const key5 in data12){let data13 = data12[key5];const _errs35 = errors;const _errs36 = errors;if(errors === _errs36){if(data13 && typeof data13 == "object" && !Array.isArray(data13)){let missing2;if(((data13.name === undefined) && (missing2 = "name")) || ((data13.description === undefined) && (missing2 = "description"))){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/required",keyword:"required",params:{missingProperty: missing2},message:"must have required property '"+missing2+"'"}];return false;}else {const _errs38 = errors;for(const key6 in data13){if(!((key6 === "name") || (key6 === "description"))){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key6},message:"must NOT have additional properties"}];return false;break;}}if(_errs38 === errors){if(data13.name !== undefined){let data14 = data13.name;const _errs39 = errors;if(errors === _errs39){if(typeof data14 === "string"){if(func2(data14) > 20){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data14) < 1){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern10.test(data14)){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/pattern",keyword:"pattern",params:{pattern: "^[ \\w]+$"},message:"must match pattern \""+"^[ \\w]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid12 = _errs39 === errors;}else {var valid12 = true;}if(valid12){if(data13.description !== undefined){let data15 = data13.description;const _errs41 = errors;if(errors === _errs41){if(typeof data15 === "string"){if(func2(data15) > 200){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/maxLength",keyword:"maxLength",params:{limit: 200},message:"must NOT have more than 200 characters"}];return false;}else {if(func2(data15) < 1){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern11.test(data15)){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/pattern",keyword:"pattern",params:{pattern: "^[ \\w\\.,:]+$"},message:"must match pattern \""+"^[ \\w\\.,:]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid12 = _errs41 === errors;}else {var valid12 = true;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid10 = _errs35 === errors;if(!valid10){break;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs29 === errors;}else {var valid0 = true;}if(valid0){if(data.logoURI !== undefined){let data16 = data.logoURI;const _errs43 = errors;if(errors === _errs43){if(errors === _errs43){if(typeof data16 === "string"){if(!(formats2(data16))){validate10.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""}];return false;}}else {validate10.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs43 === errors;}else {var valid0 = true;}}}}}}}}}}}else {validate10.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate10.errors = vErrors;return errors === 0;}
\ No newline at end of file
diff --git a/src/utils/__generated__/validateTokens.js b/src/utils/__generated__/validateTokens.js
new file mode 100644
index 00000000000..74da3358fcc
--- /dev/null
+++ b/src/utils/__generated__/validateTokens.js
@@ -0,0 +1 @@
+"use strict";export const validate = validate10;export default validate10;const schema11 = {"$schema":"http://json-schema.org/draft-07/schema#","$id":"https://uniswap.org/tokenlist.schema.json","title":"Uniswap Token List","description":"Schema for lists of tokens compatible with the Uniswap Interface","definitions":{"Version":{"type":"object","description":"The version of the list, used in change detection","examples":[{"major":1,"minor":0,"patch":0}],"additionalProperties":false,"properties":{"major":{"type":"integer","description":"The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.","minimum":0,"examples":[1,2]},"minor":{"type":"integer","description":"The minor version of the list. Must be incremented when tokens are added to the list.","minimum":0,"examples":[0,1]},"patch":{"type":"integer","description":"The patch version of the list. Must be incremented for any changes to the list.","minimum":0,"examples":[0,1]}},"required":["major","minor","patch"]},"TagIdentifier":{"type":"string","description":"The unique identifier of a tag","minLength":1,"maxLength":10,"pattern":"^[\\w]+$","examples":["compound","stablecoin"]},"ExtensionIdentifier":{"type":"string","description":"The name of a token extension property","minLength":1,"maxLength":40,"pattern":"^[\\w]+$","examples":["color","is_fee_on_transfer","aliases"]},"ExtensionMap":{"type":"object","description":"An object containing any arbitrary or vendor-specific token metadata","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValue"},"examples":[{"color":"#000000","is_verified_by_me":true},{"x-bridged-addresses-by-chain":{"1":{"bridgeAddress":"0x4200000000000000000000000000000000000010","tokenAddress":"0x4200000000000000000000000000000000000010"}}}]},"ExtensionPrimitiveValue":{"anyOf":[{"type":"string","minLength":1,"maxLength":42,"examples":["#00000"]},{"type":"boolean","examples":[true]},{"type":"number","examples":[15]},{"type":"null"}]},"ExtensionValue":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner0"}}]},"ExtensionValueInner0":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner1"}}]},"ExtensionValueInner1":{"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"}]},"TagDefinition":{"type":"object","description":"Definition of a tag that can be associated with a token via its identifier","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the tag","pattern":"^[ \\w]+$","minLength":1,"maxLength":20},"description":{"type":"string","description":"A user-friendly description of the tag","pattern":"^[ \\w\\.,:]+$","minLength":1,"maxLength":200}},"required":["name","description"],"examples":[{"name":"Stablecoin","description":"A token with value pegged to another asset"}]},"TokenInfo":{"type":"object","description":"Metadata for a single token in a token list","additionalProperties":false,"properties":{"chainId":{"type":"integer","description":"The chain ID of the Ethereum network where this token is deployed","minimum":1,"examples":[1,42]},"address":{"type":"string","description":"The checksummed address of the token on the specified chain ID","pattern":"^0x[a-fA-F0-9]{40}$","examples":["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]},"decimals":{"type":"integer","description":"The number of decimals for the token balance","minimum":0,"maximum":255,"examples":[18]},"name":{"type":"string","description":"The name of the token","minLength":0,"maxLength":40,"anyOf":[{"const":""},{"pattern":"^[ \\S+]+$"}],"examples":["USD Coin"]},"symbol":{"type":"string","description":"The symbol for the token","minLength":0,"maxLength":20,"anyOf":[{"const":""},{"pattern":"^\\S+$"}],"examples":["USDC"]},"logoURI":{"type":"string","description":"A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]},"tags":{"type":"array","description":"An array of tag identifiers associated with the token; tags are defined at the list level","items":{"$ref":"#/definitions/TagIdentifier"},"maxItems":10,"examples":["stablecoin","compound"]},"extensions":{"$ref":"#/definitions/ExtensionMap"}},"required":["chainId","address","decimals","name","symbol"]}},"type":"object","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the token list","minLength":1,"maxLength":30,"pattern":"^[\\w ]+$","examples":["My Token List"]},"timestamp":{"type":"string","format":"date-time","description":"The timestamp of this list version; i.e. when this immutable version of the list was created"},"version":{"$ref":"#/definitions/Version"},"tokens":{"type":"array","description":"The list of tokens included in the list","items":{"$ref":"#/definitions/TokenInfo"},"minItems":1,"maxItems":10000},"tokenMap":{"type":"object","description":"A mapping of key 'chainId_tokenAddress' to its corresponding token object","minProperties":1,"maxProperties":10000,"propertyNames":{"type":"string"},"additionalProperties":{"$ref":"#/definitions/TokenInfo"},"examples":[{"4_0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984":{"name":"Uniswap","address":"0x1f9840a85d5aF5bf1D1762F925BDADdC4201F984","symbol":"UNI","decimals":18,"chainId":4,"logoURI":"ipfs://QmXttGpZrECX5qCyXbBQiqgQNytVGeZW5Anewvh2jc4psg"}}]},"keywords":{"type":"array","description":"Keywords associated with the contents of the list; may be used in list discoverability","items":{"type":"string","description":"A keyword to describe the contents of the list","minLength":1,"maxLength":20,"pattern":"^[\\w ]+$","examples":["compound","lending","personal tokens"]},"maxItems":20,"uniqueItems":true},"tags":{"type":"object","description":"A mapping of tag identifiers to their name and description","propertyNames":{"$ref":"#/definitions/TagIdentifier"},"additionalProperties":{"$ref":"#/definitions/TagDefinition"},"maxProperties":20,"examples":[{"stablecoin":{"name":"Stablecoin","description":"A token with value pegged to another asset"}}]},"logoURI":{"type":"string","description":"A URI for the logo of the token list; prefer SVG or PNG of size 256x256","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]}},"required":["tokens"]};const schema12 = {"type":"object","description":"The version of the list, used in change detection","examples":[{"major":1,"minor":0,"patch":0}],"additionalProperties":false,"properties":{"major":{"type":"integer","description":"The major version of the list. Must be incremented when tokens are removed from the list or token addresses are changed.","minimum":0,"examples":[1,2]},"minor":{"type":"integer","description":"The minor version of the list. Must be incremented when tokens are added to the list.","minimum":0,"examples":[0,1]},"patch":{"type":"integer","description":"The patch version of the list. Must be incremented for any changes to the list.","minimum":0,"examples":[0,1]}},"required":["major","minor","patch"]};const schema14 = {"type":"string","description":"The unique identifier of a tag","minLength":1,"maxLength":10,"pattern":"^[\\w]+$","examples":["compound","stablecoin"]};const schema26 = {"type":"object","description":"Definition of a tag that can be associated with a token via its identifier","additionalProperties":false,"properties":{"name":{"type":"string","description":"The name of the tag","pattern":"^[ \\w]+$","minLength":1,"maxLength":20},"description":{"type":"string","description":"A user-friendly description of the tag","pattern":"^[ \\w\\.,:]+$","minLength":1,"maxLength":200}},"required":["name","description"],"examples":[{"name":"Stablecoin","description":"A token with value pegged to another asset"}]};const func2 = require("ajv/dist/runtime/ucs2length").default;const pattern0 = new RegExp("^[\\w ]+$", "u");const pattern4 = new RegExp("^[\\w]+$", "u");const pattern10 = new RegExp("^[ \\w]+$", "u");const pattern11 = new RegExp("^[ \\w\\.,:]+$", "u");const formats0 = require("ajv-formats/dist/formats").fullFormats["date-time"];const formats2 = require("ajv-formats/dist/formats").fullFormats.uri;const schema13 = {"type":"object","description":"Metadata for a single token in a token list","additionalProperties":false,"properties":{"chainId":{"type":"integer","description":"The chain ID of the Ethereum network where this token is deployed","minimum":1,"examples":[1,42]},"address":{"type":"string","description":"The checksummed address of the token on the specified chain ID","pattern":"^0x[a-fA-F0-9]{40}$","examples":["0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"]},"decimals":{"type":"integer","description":"The number of decimals for the token balance","minimum":0,"maximum":255,"examples":[18]},"name":{"type":"string","description":"The name of the token","minLength":0,"maxLength":40,"anyOf":[{"const":""},{"pattern":"^[ \\S+]+$"}],"examples":["USD Coin"]},"symbol":{"type":"string","description":"The symbol for the token","minLength":0,"maxLength":20,"anyOf":[{"const":""},{"pattern":"^\\S+$"}],"examples":["USDC"]},"logoURI":{"type":"string","description":"A URI to the token logo asset; if not set, interface will attempt to find a logo based on the token address; suggest SVG or PNG of size 64x64","format":"uri","examples":["ipfs://QmXfzKRvjZz3u5JRgC4v5mGVbm9ahrUiB4DgzHBsnWbTMM"]},"tags":{"type":"array","description":"An array of tag identifiers associated with the token; tags are defined at the list level","items":{"$ref":"#/definitions/TagIdentifier"},"maxItems":10,"examples":["stablecoin","compound"]},"extensions":{"$ref":"#/definitions/ExtensionMap"}},"required":["chainId","address","decimals","name","symbol"]};const pattern1 = new RegExp("^0x[a-fA-F0-9]{40}$", "u");const pattern2 = new RegExp("^[ \\S+]+$", "u");const pattern3 = new RegExp("^\\S+$", "u");const schema15 = {"type":"object","description":"An object containing any arbitrary or vendor-specific token metadata","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValue"},"examples":[{"color":"#000000","is_verified_by_me":true},{"x-bridged-addresses-by-chain":{"1":{"bridgeAddress":"0x4200000000000000000000000000000000000010","tokenAddress":"0x4200000000000000000000000000000000000010"}}}]};const schema16 = {"type":"string","description":"The name of a token extension property","minLength":1,"maxLength":40,"pattern":"^[\\w]+$","examples":["color","is_fee_on_transfer","aliases"]};const schema17 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner0"}}]};const schema18 = {"anyOf":[{"type":"string","minLength":1,"maxLength":42,"examples":["#00000"]},{"type":"boolean","examples":[true]},{"type":"number","examples":[15]},{"type":"null"}]};const schema20 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"},{"type":"object","maxProperties":10,"propertyNames":{"$ref":"#/definitions/ExtensionIdentifier"},"additionalProperties":{"$ref":"#/definitions/ExtensionValueInner1"}}]};const schema23 = {"anyOf":[{"$ref":"#/definitions/ExtensionPrimitiveValue"}]};function validate15(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const err7 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;validate15.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate15.errors = vErrors;return errors === 0;}function validate14(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const _errs12 = errors;if(errors === _errs12){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){const err7 = {instancePath,schemaPath:"#/anyOf/1/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;}else {for(const key0 in data){const _errs14 = errors;const _errs15 = errors;if(errors === _errs15){if(typeof key0 === "string"){if(func2(key0) > 40){const err8 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err8];}else {vErrors.push(err8);}errors++;}else {if(func2(key0) < 1){const err9 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err9];}else {vErrors.push(err9);}errors++;}else {if(!pattern4.test(key0)){const err10 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err10];}else {vErrors.push(err10);}errors++;}}}}else {const err11 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err11];}else {vErrors.push(err11);}errors++;}}var valid3 = _errs14 === errors;if(!valid3){const err12 = {instancePath,schemaPath:"#/anyOf/1/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err12];}else {vErrors.push(err12);}errors++;break;}}if(valid3){for(const key1 in data){const _errs18 = errors;if(!(validate15(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate15.errors : vErrors.concat(validate15.errors);errors = vErrors.length;}var valid5 = _errs18 === errors;if(!valid5){break;}}}}}else {const err13 = {instancePath,schemaPath:"#/anyOf/1/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err13];}else {vErrors.push(err13);}errors++;}}var _valid0 = _errs12 === errors;valid0 = valid0 || _valid0;}if(!valid0){const err14 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err14];}else {vErrors.push(err14);}errors++;validate14.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate14.errors = vErrors;return errors === 0;}function validate13(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;const _errs0 = errors;let valid0 = false;const _errs1 = errors;const _errs3 = errors;let valid2 = false;const _errs4 = errors;if(errors === _errs4){if(typeof data === "string"){if(func2(data) > 42){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/maxLength",keyword:"maxLength",params:{limit: 42},message:"must NOT have more than 42 characters"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(data) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}}else {const err2 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/0/type",keyword:"type",params:{type: "string"},message:"must be string"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}var _valid1 = _errs4 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs6 = errors;if(typeof data !== "boolean"){const err3 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/1/type",keyword:"type",params:{type: "boolean"},message:"must be boolean"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs6 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs8 = errors;if(!((typeof data == "number") && (isFinite(data)))){const err4 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/2/type",keyword:"type",params:{type: "number"},message:"must be number"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}var _valid1 = _errs8 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs10 = errors;if(data !== null){const err5 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf/3/type",keyword:"type",params:{type: "null"},message:"must be null"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}var _valid1 = _errs10 === errors;valid2 = valid2 || _valid1;}}}if(!valid2){const err6 = {instancePath,schemaPath:"#/definitions/ExtensionPrimitiveValue/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;}else {errors = _errs3;if(vErrors !== null){if(_errs3){vErrors.length = _errs3;}else {vErrors = null;}}}var _valid0 = _errs1 === errors;valid0 = valid0 || _valid0;if(!valid0){const _errs12 = errors;if(errors === _errs12){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){const err7 = {instancePath,schemaPath:"#/anyOf/1/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"};if(vErrors === null){vErrors = [err7];}else {vErrors.push(err7);}errors++;}else {for(const key0 in data){const _errs14 = errors;const _errs15 = errors;if(errors === _errs15){if(typeof key0 === "string"){if(func2(key0) > 40){const err8 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err8];}else {vErrors.push(err8);}errors++;}else {if(func2(key0) < 1){const err9 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err9];}else {vErrors.push(err9);}errors++;}else {if(!pattern4.test(key0)){const err10 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err10];}else {vErrors.push(err10);}errors++;}}}}else {const err11 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err11];}else {vErrors.push(err11);}errors++;}}var valid3 = _errs14 === errors;if(!valid3){const err12 = {instancePath,schemaPath:"#/anyOf/1/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err12];}else {vErrors.push(err12);}errors++;break;}}if(valid3){for(const key1 in data){const _errs18 = errors;if(!(validate14(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate14.errors : vErrors.concat(validate14.errors);errors = vErrors.length;}var valid5 = _errs18 === errors;if(!valid5){break;}}}}}else {const err13 = {instancePath,schemaPath:"#/anyOf/1/type",keyword:"type",params:{type: "object"},message:"must be object"};if(vErrors === null){vErrors = [err13];}else {vErrors.push(err13);}errors++;}}var _valid0 = _errs12 === errors;valid0 = valid0 || _valid0;}if(!valid0){const err14 = {instancePath,schemaPath:"#/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err14];}else {vErrors.push(err14);}errors++;validate13.errors = vErrors;return false;}else {errors = _errs0;if(vErrors !== null){if(_errs0){vErrors.length = _errs0;}else {vErrors = null;}}}validate13.errors = vErrors;return errors === 0;}function validate12(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){if(Object.keys(data).length > 10){validate12.errors = [{instancePath,schemaPath:"#/maxProperties",keyword:"maxProperties",params:{limit: 10},message:"must NOT have more than 10 properties"}];return false;}else {for(const key0 in data){const _errs1 = errors;const _errs2 = errors;if(errors === _errs2){if(typeof key0 === "string"){if(func2(key0) > 40){const err0 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters",propertyName:key0};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}else {if(func2(key0) < 1){const err1 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key0};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}else {if(!pattern4.test(key0)){const err2 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key0};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}}}}else {const err3 = {instancePath,schemaPath:"#/definitions/ExtensionIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key0};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}}var valid0 = _errs1 === errors;if(!valid0){const err4 = {instancePath,schemaPath:"#/propertyNames",keyword:"propertyNames",params:{propertyName: key0},message:"property name must be valid"};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;validate12.errors = vErrors;return false;break;}}if(valid0){for(const key1 in data){const _errs5 = errors;if(!(validate13(data[key1], {instancePath:instancePath+"/" + key1.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data,parentDataProperty:key1,rootData}))){vErrors = vErrors === null ? validate13.errors : vErrors.concat(validate13.errors);errors = vErrors.length;}var valid2 = _errs5 === errors;if(!valid2){break;}}}}}else {validate12.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate12.errors = vErrors;return errors === 0;}function validate11(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){let missing0;if((((((data.chainId === undefined) && (missing0 = "chainId")) || ((data.address === undefined) && (missing0 = "address"))) || ((data.decimals === undefined) && (missing0 = "decimals"))) || ((data.name === undefined) && (missing0 = "name"))) || ((data.symbol === undefined) && (missing0 = "symbol"))){validate11.errors = [{instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: missing0},message:"must have required property '"+missing0+"'"}];return false;}else {const _errs1 = errors;for(const key0 in data){if(!((((((((key0 === "chainId") || (key0 === "address")) || (key0 === "decimals")) || (key0 === "name")) || (key0 === "symbol")) || (key0 === "logoURI")) || (key0 === "tags")) || (key0 === "extensions"))){validate11.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.chainId !== undefined){let data0 = data.chainId;const _errs2 = errors;if(!(((typeof data0 == "number") && (!(data0 % 1) && !isNaN(data0))) && (isFinite(data0)))){validate11.errors = [{instancePath:instancePath+"/chainId",schemaPath:"#/properties/chainId/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs2){if((typeof data0 == "number") && (isFinite(data0))){if(data0 < 1 || isNaN(data0)){validate11.errors = [{instancePath:instancePath+"/chainId",schemaPath:"#/properties/chainId/minimum",keyword:"minimum",params:{comparison: ">=", limit: 1},message:"must be >= 1"}];return false;}}}var valid0 = _errs2 === errors;}else {var valid0 = true;}if(valid0){if(data.address !== undefined){let data1 = data.address;const _errs4 = errors;if(errors === _errs4){if(typeof data1 === "string"){if(!pattern1.test(data1)){validate11.errors = [{instancePath:instancePath+"/address",schemaPath:"#/properties/address/pattern",keyword:"pattern",params:{pattern: "^0x[a-fA-F0-9]{40}$"},message:"must match pattern \""+"^0x[a-fA-F0-9]{40}$"+"\""}];return false;}}else {validate11.errors = [{instancePath:instancePath+"/address",schemaPath:"#/properties/address/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs4 === errors;}else {var valid0 = true;}if(valid0){if(data.decimals !== undefined){let data2 = data.decimals;const _errs6 = errors;if(!(((typeof data2 == "number") && (!(data2 % 1) && !isNaN(data2))) && (isFinite(data2)))){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs6){if((typeof data2 == "number") && (isFinite(data2))){if(data2 > 255 || isNaN(data2)){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/maximum",keyword:"maximum",params:{comparison: "<=", limit: 255},message:"must be <= 255"}];return false;}else {if(data2 < 0 || isNaN(data2)){validate11.errors = [{instancePath:instancePath+"/decimals",schemaPath:"#/properties/decimals/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}}var valid0 = _errs6 === errors;}else {var valid0 = true;}if(valid0){if(data.name !== undefined){let data3 = data.name;const _errs8 = errors;const _errs10 = errors;let valid1 = false;const _errs11 = errors;if("" !== data3){const err0 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf/0/const",keyword:"const",params:{allowedValue: ""},message:"must be equal to constant"};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}var _valid0 = _errs11 === errors;valid1 = valid1 || _valid0;if(!valid1){const _errs12 = errors;if(typeof data3 === "string"){if(!pattern2.test(data3)){const err1 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf/1/pattern",keyword:"pattern",params:{pattern: "^[ \\S+]+$"},message:"must match pattern \""+"^[ \\S+]+$"+"\""};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;}}var _valid0 = _errs12 === errors;valid1 = valid1 || _valid0;}if(!valid1){const err2 = {instancePath:instancePath+"/name",schemaPath:"#/properties/name/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;validate11.errors = vErrors;return false;}else {errors = _errs10;if(vErrors !== null){if(_errs10){vErrors.length = _errs10;}else {vErrors = null;}}}if(errors === _errs8){if(typeof data3 === "string"){if(func2(data3) > 40){validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/maxLength",keyword:"maxLength",params:{limit: 40},message:"must NOT have more than 40 characters"}];return false;}else {if(func2(data3) < 0){validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/minLength",keyword:"minLength",params:{limit: 0},message:"must NOT have fewer than 0 characters"}];return false;}}}else {validate11.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs8 === errors;}else {var valid0 = true;}if(valid0){if(data.symbol !== undefined){let data4 = data.symbol;const _errs13 = errors;const _errs15 = errors;let valid2 = false;const _errs16 = errors;if("" !== data4){const err3 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf/0/const",keyword:"const",params:{allowedValue: ""},message:"must be equal to constant"};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}var _valid1 = _errs16 === errors;valid2 = valid2 || _valid1;if(!valid2){const _errs17 = errors;if(typeof data4 === "string"){if(!pattern3.test(data4)){const err4 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf/1/pattern",keyword:"pattern",params:{pattern: "^\\S+$"},message:"must match pattern \""+"^\\S+$"+"\""};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}}var _valid1 = _errs17 === errors;valid2 = valid2 || _valid1;}if(!valid2){const err5 = {instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/anyOf",keyword:"anyOf",params:{},message:"must match a schema in anyOf"};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;validate11.errors = vErrors;return false;}else {errors = _errs15;if(vErrors !== null){if(_errs15){vErrors.length = _errs15;}else {vErrors = null;}}}if(errors === _errs13){if(typeof data4 === "string"){if(func2(data4) > 20){validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data4) < 0){validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/minLength",keyword:"minLength",params:{limit: 0},message:"must NOT have fewer than 0 characters"}];return false;}}}else {validate11.errors = [{instancePath:instancePath+"/symbol",schemaPath:"#/properties/symbol/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs13 === errors;}else {var valid0 = true;}if(valid0){if(data.logoURI !== undefined){let data5 = data.logoURI;const _errs18 = errors;if(errors === _errs18){if(errors === _errs18){if(typeof data5 === "string"){if(!(formats2(data5))){validate11.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""}];return false;}}else {validate11.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs18 === errors;}else {var valid0 = true;}if(valid0){if(data.tags !== undefined){let data6 = data.tags;const _errs20 = errors;if(errors === _errs20){if(Array.isArray(data6)){if(data6.length > 10){validate11.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/maxItems",keyword:"maxItems",params:{limit: 10},message:"must NOT have more than 10 items"}];return false;}else {var valid3 = true;const len0 = data6.length;for(let i0=0; i0<len0; i0++){let data7 = data6[i0];const _errs22 = errors;const _errs23 = errors;if(errors === _errs23){if(typeof data7 === "string"){if(func2(data7) > 10){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/maxLength",keyword:"maxLength",params:{limit: 10},message:"must NOT have more than 10 characters"}];return false;}else {if(func2(data7) < 1){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern4.test(data7)){validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\""}];return false;}}}}else {validate11.errors = [{instancePath:instancePath+"/tags/" + i0,schemaPath:"#/definitions/TagIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid3 = _errs22 === errors;if(!valid3){break;}}}}else {validate11.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs20 === errors;}else {var valid0 = true;}if(valid0){if(data.extensions !== undefined){const _errs25 = errors;if(!(validate12(data.extensions, {instancePath:instancePath+"/extensions",parentData:data,parentDataProperty:"extensions",rootData}))){vErrors = vErrors === null ? validate12.errors : vErrors.concat(validate12.errors);errors = vErrors.length;}var valid0 = _errs25 === errors;}else {var valid0 = true;}}}}}}}}}}}else {validate11.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate11.errors = vErrors;return errors === 0;}function validate10(data, {instancePath="", parentData, parentDataProperty, rootData=data}={}){/*# sourceURL="https://uniswap.org/tokenlist.schema.json" */;let vErrors = null;let errors = 0;if(errors === 0){if(data && typeof data == "object" && !Array.isArray(data)){let missing0;if((data.tokens === undefined) && (missing0 = "tokens")){validate10.errors = [{instancePath,schemaPath:"#/required",keyword:"required",params:{missingProperty: missing0},message:"must have required property '"+missing0+"'"}];return false;}else {const _errs1 = errors;for(const key0 in data){if(!((((((((key0 === "name") || (key0 === "timestamp")) || (key0 === "version")) || (key0 === "tokens")) || (key0 === "tokenMap")) || (key0 === "keywords")) || (key0 === "tags")) || (key0 === "logoURI"))){validate10.errors = [{instancePath,schemaPath:"#/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key0},message:"must NOT have additional properties"}];return false;break;}}if(_errs1 === errors){if(data.name !== undefined){let data0 = data.name;const _errs2 = errors;if(errors === _errs2){if(typeof data0 === "string"){if(func2(data0) > 30){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/maxLength",keyword:"maxLength",params:{limit: 30},message:"must NOT have more than 30 characters"}];return false;}else {if(func2(data0) < 1){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern0.test(data0)){validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/pattern",keyword:"pattern",params:{pattern: "^[\\w ]+$"},message:"must match pattern \""+"^[\\w ]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/name",schemaPath:"#/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid0 = _errs2 === errors;}else {var valid0 = true;}if(valid0){if(data.timestamp !== undefined){let data1 = data.timestamp;const _errs4 = errors;if(errors === _errs4){if(errors === _errs4){if(typeof data1 === "string"){if(!(formats0.validate(data1))){validate10.errors = [{instancePath:instancePath+"/timestamp",schemaPath:"#/properties/timestamp/format",keyword:"format",params:{format: "date-time"},message:"must match format \""+"date-time"+"\""}];return false;}}else {validate10.errors = [{instancePath:instancePath+"/timestamp",schemaPath:"#/properties/timestamp/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs4 === errors;}else {var valid0 = true;}if(valid0){if(data.version !== undefined){let data2 = data.version;const _errs6 = errors;const _errs7 = errors;if(errors === _errs7){if(data2 && typeof data2 == "object" && !Array.isArray(data2)){let missing1;if((((data2.major === undefined) && (missing1 = "major")) || ((data2.minor === undefined) && (missing1 = "minor"))) || ((data2.patch === undefined) && (missing1 = "patch"))){validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/required",keyword:"required",params:{missingProperty: missing1},message:"must have required property '"+missing1+"'"}];return false;}else {const _errs9 = errors;for(const key1 in data2){if(!(((key1 === "major") || (key1 === "minor")) || (key1 === "patch"))){validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key1},message:"must NOT have additional properties"}];return false;break;}}if(_errs9 === errors){if(data2.major !== undefined){let data3 = data2.major;const _errs10 = errors;if(!(((typeof data3 == "number") && (!(data3 % 1) && !isNaN(data3))) && (isFinite(data3)))){validate10.errors = [{instancePath:instancePath+"/version/major",schemaPath:"#/definitions/Version/properties/major/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs10){if((typeof data3 == "number") && (isFinite(data3))){if(data3 < 0 || isNaN(data3)){validate10.errors = [{instancePath:instancePath+"/version/major",schemaPath:"#/definitions/Version/properties/major/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs10 === errors;}else {var valid2 = true;}if(valid2){if(data2.minor !== undefined){let data4 = data2.minor;const _errs12 = errors;if(!(((typeof data4 == "number") && (!(data4 % 1) && !isNaN(data4))) && (isFinite(data4)))){validate10.errors = [{instancePath:instancePath+"/version/minor",schemaPath:"#/definitions/Version/properties/minor/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs12){if((typeof data4 == "number") && (isFinite(data4))){if(data4 < 0 || isNaN(data4)){validate10.errors = [{instancePath:instancePath+"/version/minor",schemaPath:"#/definitions/Version/properties/minor/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs12 === errors;}else {var valid2 = true;}if(valid2){if(data2.patch !== undefined){let data5 = data2.patch;const _errs14 = errors;if(!(((typeof data5 == "number") && (!(data5 % 1) && !isNaN(data5))) && (isFinite(data5)))){validate10.errors = [{instancePath:instancePath+"/version/patch",schemaPath:"#/definitions/Version/properties/patch/type",keyword:"type",params:{type: "integer"},message:"must be integer"}];return false;}if(errors === _errs14){if((typeof data5 == "number") && (isFinite(data5))){if(data5 < 0 || isNaN(data5)){validate10.errors = [{instancePath:instancePath+"/version/patch",schemaPath:"#/definitions/Version/properties/patch/minimum",keyword:"minimum",params:{comparison: ">=", limit: 0},message:"must be >= 0"}];return false;}}}var valid2 = _errs14 === errors;}else {var valid2 = true;}}}}}}else {validate10.errors = [{instancePath:instancePath+"/version",schemaPath:"#/definitions/Version/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs6 === errors;}else {var valid0 = true;}if(valid0){if(data.tokens !== undefined){let data6 = data.tokens;const _errs16 = errors;if(errors === _errs16){if(Array.isArray(data6)){if(data6.length > 10000){validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/maxItems",keyword:"maxItems",params:{limit: 10000},message:"must NOT have more than 10000 items"}];return false;}else {if(data6.length < 1){validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/minItems",keyword:"minItems",params:{limit: 1},message:"must NOT have fewer than 1 items"}];return false;}else {var valid3 = true;const len0 = data6.length;for(let i0=0; i0<len0; i0++){const _errs18 = errors;if(!(validate11(data6[i0], {instancePath:instancePath+"/tokens/" + i0,parentData:data6,parentDataProperty:i0,rootData}))){vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);errors = vErrors.length;}var valid3 = _errs18 === errors;if(!valid3){break;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tokens",schemaPath:"#/properties/tokens/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs16 === errors;}else {var valid0 = true;}if(valid0){if(data.tokenMap !== undefined){let data8 = data.tokenMap;const _errs19 = errors;if(errors === _errs19){if(data8 && typeof data8 == "object" && !Array.isArray(data8)){if(Object.keys(data8).length > 10000){validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/maxProperties",keyword:"maxProperties",params:{limit: 10000},message:"must NOT have more than 10000 properties"}];return false;}else {if(Object.keys(data8).length < 1){validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/minProperties",keyword:"minProperties",params:{limit: 1},message:"must NOT have fewer than 1 properties"}];return false;}else {for(const key2 in data8){const _errs21 = errors;if(typeof key2 !== "string"){const err0 = {instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/propertyNames/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key2};if(vErrors === null){vErrors = [err0];}else {vErrors.push(err0);}errors++;}var valid4 = _errs21 === errors;if(!valid4){const err1 = {instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/propertyNames",keyword:"propertyNames",params:{propertyName: key2},message:"property name must be valid"};if(vErrors === null){vErrors = [err1];}else {vErrors.push(err1);}errors++;validate10.errors = vErrors;return false;break;}}if(valid4){for(const key3 in data8){const _errs24 = errors;if(!(validate11(data8[key3], {instancePath:instancePath+"/tokenMap/" + key3.replace(/~/g, "~0").replace(/\//g, "~1"),parentData:data8,parentDataProperty:key3,rootData}))){vErrors = vErrors === null ? validate11.errors : vErrors.concat(validate11.errors);errors = vErrors.length;}var valid5 = _errs24 === errors;if(!valid5){break;}}}}}}else {validate10.errors = [{instancePath:instancePath+"/tokenMap",schemaPath:"#/properties/tokenMap/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs19 === errors;}else {var valid0 = true;}if(valid0){if(data.keywords !== undefined){let data10 = data.keywords;const _errs25 = errors;if(errors === _errs25){if(Array.isArray(data10)){if(data10.length > 20){validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/maxItems",keyword:"maxItems",params:{limit: 20},message:"must NOT have more than 20 items"}];return false;}else {var valid6 = true;const len1 = data10.length;for(let i1=0; i1<len1; i1++){let data11 = data10[i1];const _errs27 = errors;if(errors === _errs27){if(typeof data11 === "string"){if(func2(data11) > 20){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data11) < 1){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern0.test(data11)){validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/pattern",keyword:"pattern",params:{pattern: "^[\\w ]+$"},message:"must match pattern \""+"^[\\w ]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/keywords/" + i1,schemaPath:"#/properties/keywords/items/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid6 = _errs27 === errors;if(!valid6){break;}}if(valid6){let i2 = data10.length;let j0;if(i2 > 1){const indices0 = {};for(;i2--;){let item0 = data10[i2];if(typeof item0 !== "string"){continue;}if(typeof indices0[item0] == "number"){j0 = indices0[item0];validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/uniqueItems",keyword:"uniqueItems",params:{i: i2, j: j0},message:"must NOT have duplicate items (items ## "+j0+" and "+i2+" are identical)"}];return false;break;}indices0[item0] = i2;}}}}}else {validate10.errors = [{instancePath:instancePath+"/keywords",schemaPath:"#/properties/keywords/type",keyword:"type",params:{type: "array"},message:"must be array"}];return false;}}var valid0 = _errs25 === errors;}else {var valid0 = true;}if(valid0){if(data.tags !== undefined){let data12 = data.tags;const _errs29 = errors;if(errors === _errs29){if(data12 && typeof data12 == "object" && !Array.isArray(data12)){if(Object.keys(data12).length > 20){validate10.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/maxProperties",keyword:"maxProperties",params:{limit: 20},message:"must NOT have more than 20 properties"}];return false;}else {for(const key4 in data12){const _errs31 = errors;const _errs32 = errors;if(errors === _errs32){if(typeof key4 === "string"){if(func2(key4) > 10){const err2 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/maxLength",keyword:"maxLength",params:{limit: 10},message:"must NOT have more than 10 characters",propertyName:key4};if(vErrors === null){vErrors = [err2];}else {vErrors.push(err2);}errors++;}else {if(func2(key4) < 1){const err3 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters",propertyName:key4};if(vErrors === null){vErrors = [err3];}else {vErrors.push(err3);}errors++;}else {if(!pattern4.test(key4)){const err4 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/pattern",keyword:"pattern",params:{pattern: "^[\\w]+$"},message:"must match pattern \""+"^[\\w]+$"+"\"",propertyName:key4};if(vErrors === null){vErrors = [err4];}else {vErrors.push(err4);}errors++;}}}}else {const err5 = {instancePath:instancePath+"/tags",schemaPath:"#/definitions/TagIdentifier/type",keyword:"type",params:{type: "string"},message:"must be string",propertyName:key4};if(vErrors === null){vErrors = [err5];}else {vErrors.push(err5);}errors++;}}var valid8 = _errs31 === errors;if(!valid8){const err6 = {instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/propertyNames",keyword:"propertyNames",params:{propertyName: key4},message:"property name must be valid"};if(vErrors === null){vErrors = [err6];}else {vErrors.push(err6);}errors++;validate10.errors = vErrors;return false;break;}}if(valid8){for(const key5 in data12){let data13 = data12[key5];const _errs35 = errors;const _errs36 = errors;if(errors === _errs36){if(data13 && typeof data13 == "object" && !Array.isArray(data13)){let missing2;if(((data13.name === undefined) && (missing2 = "name")) || ((data13.description === undefined) && (missing2 = "description"))){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/required",keyword:"required",params:{missingProperty: missing2},message:"must have required property '"+missing2+"'"}];return false;}else {const _errs38 = errors;for(const key6 in data13){if(!((key6 === "name") || (key6 === "description"))){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/additionalProperties",keyword:"additionalProperties",params:{additionalProperty: key6},message:"must NOT have additional properties"}];return false;break;}}if(_errs38 === errors){if(data13.name !== undefined){let data14 = data13.name;const _errs39 = errors;if(errors === _errs39){if(typeof data14 === "string"){if(func2(data14) > 20){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/maxLength",keyword:"maxLength",params:{limit: 20},message:"must NOT have more than 20 characters"}];return false;}else {if(func2(data14) < 1){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern10.test(data14)){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/pattern",keyword:"pattern",params:{pattern: "^[ \\w]+$"},message:"must match pattern \""+"^[ \\w]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/name",schemaPath:"#/definitions/TagDefinition/properties/name/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid12 = _errs39 === errors;}else {var valid12 = true;}if(valid12){if(data13.description !== undefined){let data15 = data13.description;const _errs41 = errors;if(errors === _errs41){if(typeof data15 === "string"){if(func2(data15) > 200){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/maxLength",keyword:"maxLength",params:{limit: 200},message:"must NOT have more than 200 characters"}];return false;}else {if(func2(data15) < 1){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/minLength",keyword:"minLength",params:{limit: 1},message:"must NOT have fewer than 1 characters"}];return false;}else {if(!pattern11.test(data15)){validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/pattern",keyword:"pattern",params:{pattern: "^[ \\w\\.,:]+$"},message:"must match pattern \""+"^[ \\w\\.,:]+$"+"\""}];return false;}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1")+"/description",schemaPath:"#/definitions/TagDefinition/properties/description/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}var valid12 = _errs41 === errors;}else {var valid12 = true;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tags/" + key5.replace(/~/g, "~0").replace(/\//g, "~1"),schemaPath:"#/definitions/TagDefinition/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid10 = _errs35 === errors;if(!valid10){break;}}}}}else {validate10.errors = [{instancePath:instancePath+"/tags",schemaPath:"#/properties/tags/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}var valid0 = _errs29 === errors;}else {var valid0 = true;}if(valid0){if(data.logoURI !== undefined){let data16 = data.logoURI;const _errs43 = errors;if(errors === _errs43){if(errors === _errs43){if(typeof data16 === "string"){if(!(formats2(data16))){validate10.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/format",keyword:"format",params:{format: "uri"},message:"must match format \""+"uri"+"\""}];return false;}}else {validate10.errors = [{instancePath:instancePath+"/logoURI",schemaPath:"#/properties/logoURI/type",keyword:"type",params:{type: "string"},message:"must be string"}];return false;}}}var valid0 = _errs43 === errors;}else {var valid0 = true;}}}}}}}}}}}else {validate10.errors = [{instancePath,schemaPath:"#/type",keyword:"type",params:{type: "object"},message:"must be object"}];return false;}}validate10.errors = vErrors;return errors === 0;}
\ No newline at end of file