@ludo.ninja/api 2.8.28 → 2.8.30

package/src/graphql_tools/__generated__/searchHost/schema.ts

@@ -0,0 +1,2137 @@
+/* eslint-disable */
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T | null;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  /** scalar Upload */
+  Long: any;
+};
+
+
+
+export type IAsset = {
+  assetId: Scalars['ID'];
+  blockchain?: Maybe<Scalars['String']>;
+  blockchainLabel?: Maybe<Scalars['String']>;
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  collection?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  chainId?: Maybe<Scalars['String']>;
+  blockHeight?: Maybe<Scalars['Long']>;
+  blockTimestamp?: Maybe<Scalars['Long']>;
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  medias?: Maybe<Array<Maybe<IMedia>>>;
+  ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+  creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+  attributes?: Maybe<Array<Maybe<IAttribute>>>;
+  likes?: Maybe<Scalars['Int']>;
+  liked?: Maybe<Scalars['Boolean']>;
+  views?: Maybe<Scalars['Int']>;
+  visible?: Maybe<Scalars['Boolean']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  blurred?: Maybe<Scalars['Boolean']>;
+  rank?: Maybe<Scalars['Float']>;
+  trueRank?: Maybe<Scalars['Float']>;
+  rankRaw?: Maybe<Scalars['Float']>;
+  rankMax?: Maybe<Scalars['Float']>;
+  rankUpdatedAt?: Maybe<Scalars['Float']>;
+  collectionId?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+  collectionOriginalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  collectionMedias?: Maybe<Array<Maybe<IMedia>>>;
+  markets?: Maybe<Array<Maybe<IAssetMarket>>>;
+  latestPriceBlockHeight?: Maybe<Scalars['Long']>;
+  latestPriceCurrency?: Maybe<Scalars['String']>;
+  latestPriceAmount?: Maybe<Scalars['Float']>;
+  totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+  category?: Maybe<Scalars['String']>;
+  categoryLabel?: Maybe<Scalars['String']>;
+};
+
+export type IAssetMarket = {
+  marketId?: Maybe<Scalars['String']>;
+  marketName?: Maybe<Scalars['String']>;
+  marketDomain?: Maybe<Scalars['String']>;
+  marketUrl?: Maybe<Scalars['String']>;
+};
+
+export type IAssetRank = {
+  assetId: Scalars['String'];
+  rank?: Maybe<Scalars['Float']>;
+};
+
+export type IAssetsPage = {
+  assets: Array<Maybe<IAsset>>;
+  nextPage?: Maybe<IPage>;
+};
+
+export type IAttribute = {
+  name?: Maybe<Scalars['String']>;
+  value?: Maybe<Scalars['String']>;
+};
+
+export type ICollection = {
+  collectionId: Scalars['ID'];
+  blockchain?: Maybe<Scalars['String']>;
+  identifier?: Maybe<Scalars['String']>;
+  contractAddress?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  blockHeight?: Maybe<Scalars['Long']>;
+  blockTimestamp?: Maybe<Scalars['Long']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+  collectionUrl?: Maybe<Scalars['String']>;
+  items?: Maybe<Scalars['Int']>;
+  owners?: Maybe<Scalars['Int']>;
+  floorPrices?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+  totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+  collectionMarkets?: Maybe<Array<Maybe<ICollectionMarket>>>;
+  creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+  verified?: Maybe<Scalars['Boolean']>;
+  originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  medias?: Maybe<Array<Maybe<IMedia>>>;
+  nsfw?: Maybe<Scalars['Int']>;
+  likes?: Maybe<Scalars['Int']>;
+  liked?: Maybe<Scalars['Boolean']>;
+  rank?: Maybe<Scalars['Float']>;
+};
+
+export type ICollectionFilterInput = {
+  blockchain: Scalars['String'];
+  category: Scalars['String'];
+  time: Scalars['String'];
+  status: Scalars['String'];
+};
+
+export type ICollectionMarket = {
+  marketId?: Maybe<Scalars['String']>;
+  marketName?: Maybe<Scalars['String']>;
+  marketDomain?: Maybe<Scalars['String']>;
+  marketUrl?: Maybe<Scalars['String']>;
+};
+
+export type ICollectionPage = {
+  collections: Array<Maybe<ICollection>>;
+  nextPage?: Maybe<IPage>;
+};
+
+export type ICreation = {
+  creationId: Scalars['String'];
+  itemType: Scalars['String'];
+  itemId: Scalars['String'];
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+  creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  media?: Maybe<Scalars['String']>;
+  mediaPreview?: Maybe<Scalars['String']>;
+  mimeType?: Maybe<Scalars['String']>;
+  likes?: Maybe<Scalars['Int']>;
+  liked?: Maybe<Scalars['Boolean']>;
+  rank?: Maybe<Scalars['Float']>;
+};
+
+export type ICreationFilterInput = {
+  type: Scalars['String'];
+  blockchain: Scalars['String'];
+  category: Scalars['String'];
+  time: Scalars['String'];
+  status: Scalars['String'];
+};
+
+export type ICreationsPage = {
+  creations: Array<Maybe<ICreation>>;
+  nextPage?: Maybe<IPage>;
+};
+
+export type ICurrencyAmountPair = {
+  currency?: Maybe<Scalars['String']>;
+  amount?: Maybe<Scalars['Float']>;
+};
+
+export type IDynamicAssetData = {
+  assetId: Scalars['String'];
+  isLikedByUser?: Maybe<Scalars['Boolean']>;
+  likesNum?: Maybe<Scalars['Int']>;
+  medias?: Maybe<Array<Maybe<IMedia>>>;
+};
+
+export type IDynamicCollectionData = {
+  collectionId: Scalars['String'];
+  isLikedByUser?: Maybe<Scalars['Boolean']>;
+  likesNum?: Maybe<Scalars['Int']>;
+  collectionAssetsPage?: Maybe<IAssetsPage>;
+};
+
+export type IDynamicCollectionDataInput = {
+  collectionId: Scalars['String'];
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IMedia = {
+  originalUrl?: Maybe<Scalars['String']>;
+  url?: Maybe<Scalars['String']>;
+  previewUrl?: Maybe<Scalars['String']>;
+  mimeType?: Maybe<Scalars['String']>;
+  sizeRatio?: Maybe<Scalars['Float']>;
+  fileSize?: Maybe<Scalars['Long']>;
+  nsfw?: Maybe<Scalars['Int']>;
+  originalMime?: Maybe<Scalars['String']>;
+  hidden?: Maybe<Scalars['Boolean']>;
+  cover?: Maybe<Scalars['Boolean']>;
+};
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  clearCaches: Scalars['Boolean'];
+};
+
+export type IPage = {
+  token?: Maybe<Scalars['String']>;
+  num?: Maybe<Scalars['Int']>;
+  size?: Maybe<Scalars['Int']>;
+  elements?: Maybe<Scalars['Long']>;
+};
+
+export type IPageInput = {
+  token?: Maybe<Scalars['String']>;
+  size?: Maybe<Scalars['Int']>;
+};
+
+export type IProfile = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  about?: Maybe<Scalars['String']>;
+  userpic?: Maybe<Scalars['String']>;
+  followers?: Maybe<Scalars['Int']>;
+  followings?: Maybe<Scalars['Int']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  deletedAt?: Maybe<Scalars['Long']>;
+  visible?: Maybe<Scalars['Boolean']>;
+  views?: Maybe<Scalars['Int']>;
+  deleted?: Maybe<Scalars['Boolean']>;
+};
+
+export type IProfilePage = {
+  profiles: Array<Maybe<IProfile>>;
+  nextPage?: Maybe<IPage>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchUserPortfolio: Array<Maybe<ICurrencyAmountPair>>;
+  fetchAssetByBlockchain: IAsset;
+  fetchDynamicAssetData: IDynamicAssetData;
+  fetchDynamicAssetsData: Array<Maybe<IDynamicAssetData>>;
+  fetchAssets: Array<Maybe<IAsset>>;
+  fetchAssetRank: IAssetRank;
+  fetchAssetRanks: Array<Maybe<IAssetRank>>;
+  findCollections: ICollectionPage;
+  fetchCollection: ICollection;
+  fetchCollectionsByIds: Array<ICollection>;
+  fetchDynamicCollectionData: IDynamicCollectionData;
+  fetchDynamicCollectionsData: Array<IDynamicCollectionData>;
+  findAllTopEntitiesByName: ITopEntitiesPage;
+  fetchAllCreations: ICreationsPage;
+  fetchCreationsByType: ICreationsPage;
+  findCreations: ICreationsPage;
+  findUserCreations: ICreationsPage;
+  findProfilesByName: IProfilePage;
+};
+
+
+export type IQueryFetchUserPortfolioArgs = {
+  ownerId: Scalars['String'];
+};
+
+
+export type IQueryFetchAssetByBlockchainArgs = {
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+};
+
+
+export type IQueryFetchDynamicAssetDataArgs = {
+  assetId: Scalars['String'];
+};
+
+
+export type IQueryFetchDynamicAssetsDataArgs = {
+  assetIds: Array<Scalars['String']>;
+};
+
+
+export type IQueryFetchAssetsArgs = {
+  assetIds: Array<Scalars['String']>;
+};
+
+
+export type IQueryFetchAssetRankArgs = {
+  assetId: Scalars['String'];
+};
+
+
+export type IQueryFetchAssetRanksArgs = {
+  assetIds: Array<Scalars['String']>;
+};
+
+
+export type IQueryFindCollectionsArgs = {
+  term: Scalars['String'];
+  input: ICollectionFilterInput;
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IQueryFetchCollectionArgs = {
+  collectionId: Scalars['String'];
+};
+
+
+export type IQueryFetchCollectionsByIdsArgs = {
+  collectionIds: Array<Scalars['String']>;
+};
+
+
+export type IQueryFetchDynamicCollectionDataArgs = {
+  input: IDynamicCollectionDataInput;
+};
+
+
+export type IQueryFetchDynamicCollectionsDataArgs = {
+  inputs: Array<IDynamicCollectionDataInput>;
+};
+
+
+export type IQueryFindAllTopEntitiesByNameArgs = {
+  name: Scalars['String'];
+  pageSize: Scalars['Int'];
+};
+
+
+export type IQueryFetchAllCreationsArgs = {
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IQueryFetchCreationsByTypeArgs = {
+  itemType: Scalars['String'];
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IQueryFindCreationsArgs = {
+  term: Scalars['String'];
+  input: ICreationFilterInput;
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IQueryFindUserCreationsArgs = {
+  ownerId: Scalars['String'];
+  input: ICreationFilterInput;
+  page?: Maybe<IPageInput>;
+};
+
+
+export type IQueryFindProfilesByNameArgs = {
+  name: Scalars['String'];
+  page?: Maybe<IPageInput>;
+};
+
+export type ITopEntitiesPage = {
+  assets: Array<Maybe<IAsset>>;
+  collections: Array<Maybe<ICollection>>;
+  profiles: Array<Maybe<IProfile>>;
+};
+
+
+
+export type ResolverTypeWrapper<T> = Promise<T> | T;
+
+
+export type ResolverWithResolve<TResult, TParent, TContext, TArgs> = {
+  resolve: ResolverFn<TResult, TParent, TContext, TArgs>;
+};
+export type Resolver<TResult, TParent = {}, TContext = {}, TArgs = {}> = ResolverFn<TResult, TParent, TContext, TArgs> | ResolverWithResolve<TResult, TParent, TContext, TArgs>;
+
+export type ResolverFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Promise<TResult> | TResult;
+
+export type SubscriptionSubscribeFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => AsyncIterable<TResult> | Promise<AsyncIterable<TResult>>;
+
+export type SubscriptionResolveFn<TResult, TParent, TContext, TArgs> = (
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+export interface SubscriptionSubscriberObject<TResult, TKey extends string, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<{ [key in TKey]: TResult }, TParent, TContext, TArgs>;
+  resolve?: SubscriptionResolveFn<TResult, { [key in TKey]: TResult }, TContext, TArgs>;
+}
+
+export interface SubscriptionResolverObject<TResult, TParent, TContext, TArgs> {
+  subscribe: SubscriptionSubscribeFn<any, TParent, TContext, TArgs>;
+  resolve: SubscriptionResolveFn<TResult, any, TContext, TArgs>;
+}
+
+export type SubscriptionObject<TResult, TKey extends string, TParent, TContext, TArgs> =
+  | SubscriptionSubscriberObject<TResult, TKey, TParent, TContext, TArgs>
+  | SubscriptionResolverObject<TResult, TParent, TContext, TArgs>;
+
+export type SubscriptionResolver<TResult, TKey extends string, TParent = {}, TContext = {}, TArgs = {}> =
+  | ((...args: any[]) => SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>)
+  | SubscriptionObject<TResult, TKey, TParent, TContext, TArgs>;
+
+export type TypeResolveFn<TTypes, TParent = {}, TContext = {}> = (
+  parent: TParent,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => Maybe<TTypes> | Promise<Maybe<TTypes>>;
+
+export type IsTypeOfResolverFn<T = {}, TContext = {}> = (obj: T, context: TContext, info: GraphQLResolveInfo) => boolean | Promise<boolean>;
+
+export type NextResolverFn<T> = () => Promise<T>;
+
+export type DirectiveResolverFn<TResult = {}, TParent = {}, TContext = {}, TArgs = {}> = (
+  next: NextResolverFn<TResult>,
+  parent: TParent,
+  args: TArgs,
+  context: TContext,
+  info: GraphQLResolveInfo
+) => TResult | Promise<TResult>;
+
+/** Mapping between all available schema types and the resolvers types */
+export type IResolversTypes = {
+  Asset: ResolverTypeWrapper<IAsset>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  AssetMarket: ResolverTypeWrapper<IAssetMarket>;
+  AssetRank: ResolverTypeWrapper<IAssetRank>;
+  AssetsPage: ResolverTypeWrapper<IAssetsPage>;
+  Attribute: ResolverTypeWrapper<IAttribute>;
+  Collection: ResolverTypeWrapper<ICollection>;
+  CollectionFilterInput: ICollectionFilterInput;
+  CollectionMarket: ResolverTypeWrapper<ICollectionMarket>;
+  CollectionPage: ResolverTypeWrapper<ICollectionPage>;
+  Creation: ResolverTypeWrapper<ICreation>;
+  CreationFilterInput: ICreationFilterInput;
+  CreationsPage: ResolverTypeWrapper<ICreationsPage>;
+  CurrencyAmountPair: ResolverTypeWrapper<ICurrencyAmountPair>;
+  DynamicAssetData: ResolverTypeWrapper<IDynamicAssetData>;
+  DynamicCollectionData: ResolverTypeWrapper<IDynamicCollectionData>;
+  DynamicCollectionDataInput: IDynamicCollectionDataInput;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Media: ResolverTypeWrapper<IMedia>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Page: ResolverTypeWrapper<IPage>;
+  PageInput: IPageInput;
+  Profile: ResolverTypeWrapper<IProfile>;
+  ProfilePage: ResolverTypeWrapper<IProfilePage>;
+  Query: ResolverTypeWrapper<{}>;
+  TopEntitiesPage: ResolverTypeWrapper<ITopEntitiesPage>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  Asset: IAsset;
+  ID: Scalars['ID'];
+  String: Scalars['String'];
+  Int: Scalars['Int'];
+  Boolean: Scalars['Boolean'];
+  Float: Scalars['Float'];
+  AssetMarket: IAssetMarket;
+  AssetRank: IAssetRank;
+  AssetsPage: IAssetsPage;
+  Attribute: IAttribute;
+  Collection: ICollection;
+  CollectionFilterInput: ICollectionFilterInput;
+  CollectionMarket: ICollectionMarket;
+  CollectionPage: ICollectionPage;
+  Creation: ICreation;
+  CreationFilterInput: ICreationFilterInput;
+  CreationsPage: ICreationsPage;
+  CurrencyAmountPair: ICurrencyAmountPair;
+  DynamicAssetData: IDynamicAssetData;
+  DynamicCollectionData: IDynamicCollectionData;
+  DynamicCollectionDataInput: IDynamicCollectionDataInput;
+  Long: Scalars['Long'];
+  Media: IMedia;
+  Mutation: {};
+  Page: IPage;
+  PageInput: IPageInput;
+  Profile: IProfile;
+  ProfilePage: IProfilePage;
+  Query: {};
+  TopEntitiesPage: ITopEntitiesPage;
+};
+
+export type INotBlankDirectiveArgs = {
+  message?: Maybe<Scalars['String']>;
+};
+
+export type INotBlankDirectiveResolver<Result, Parent, ContextType = any, Args = INotBlankDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IAssetResolvers<ContextType = any, ParentType extends IResolversParentTypes['Asset'] = IResolversParentTypes['Asset']> = {
+  assetId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  blockchain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  blockchainLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  address?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collection?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  chainId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  blockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  blockTimestamp?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  originalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  ownersAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  ownersProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
+  creatorsAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  creatorsProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
+  attributes?: Resolver<Maybe<Array<Maybe<IResolversTypes['Attribute']>>>, ParentType, ContextType>;
+  likes?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  liked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  blurred?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  trueRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  rankRaw?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  rankMax?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  rankUpdatedAt?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  collectionId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionOriginalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  collectionMedias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  markets?: Resolver<Maybe<Array<Maybe<IResolversTypes['AssetMarket']>>>, ParentType, ContextType>;
+  latestPriceBlockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  latestPriceCurrency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  latestPriceAmount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  totalVolumes?: Resolver<Maybe<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>>, ParentType, ContextType>;
+  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  categoryLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAssetMarketResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetMarket'] = IResolversParentTypes['AssetMarket']> = {
+  marketId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketDomain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAssetRankResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetRank'] = IResolversParentTypes['AssetRank']> = {
+  assetId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAssetsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetsPage'] = IResolversParentTypes['AssetsPage']> = {
+  assets?: Resolver<Array<Maybe<IResolversTypes['Asset']>>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['Page']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAttributeResolvers<ContextType = any, ParentType extends IResolversParentTypes['Attribute'] = IResolversParentTypes['Attribute']> = {
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICollectionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Collection'] = IResolversParentTypes['Collection']> = {
+  collectionId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  blockchain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  identifier?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  contractAddress?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  blockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  blockTimestamp?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  items?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  owners?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  floorPrices?: Resolver<Maybe<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>>, ParentType, ContextType>;
+  totalVolumes?: Resolver<Maybe<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>>, ParentType, ContextType>;
+  collectionMarkets?: Resolver<Maybe<Array<Maybe<IResolversTypes['CollectionMarket']>>>, ParentType, ContextType>;
+  creatorsAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  creatorsProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
+  verified?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  originalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  nsfw?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  likes?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  liked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICollectionMarketResolvers<ContextType = any, ParentType extends IResolversParentTypes['CollectionMarket'] = IResolversParentTypes['CollectionMarket']> = {
+  marketId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketDomain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICollectionPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['CollectionPage'] = IResolversParentTypes['CollectionPage']> = {
+  collections?: Resolver<Array<Maybe<IResolversTypes['Collection']>>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['Page']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICreationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Creation'] = IResolversParentTypes['Creation']> = {
+  creationId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  itemType?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  itemId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  blockchain?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  address?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  creatorsAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  originalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mediaPreview?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mimeType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  likes?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  liked?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICreationsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['CreationsPage'] = IResolversParentTypes['CreationsPage']> = {
+  creations?: Resolver<Array<Maybe<IResolversTypes['Creation']>>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['Page']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICurrencyAmountPairResolvers<ContextType = any, ParentType extends IResolversParentTypes['CurrencyAmountPair'] = IResolversParentTypes['CurrencyAmountPair']> = {
+  currency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  amount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IDynamicAssetDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['DynamicAssetData'] = IResolversParentTypes['DynamicAssetData']> = {
+  assetId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  isLikedByUser?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  likesNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IDynamicCollectionDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['DynamicCollectionData'] = IResolversParentTypes['DynamicCollectionData']> = {
+  collectionId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  isLikedByUser?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  likesNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  collectionAssetsPage?: Resolver<Maybe<IResolversTypes['AssetsPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
+  name: 'Long';
+}
+
+export type IMediaResolvers<ContextType = any, ParentType extends IResolversParentTypes['Media'] = IResolversParentTypes['Media']> = {
+  originalUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  previewUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mimeType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  sizeRatio?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  fileSize?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  nsfw?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  originalMime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  hidden?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  cover?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  clearCaches?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+};
+
+export type IPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['Page'] = IResolversParentTypes['Page']> = {
+  token?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  num?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  elements?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IProfileResolvers<ContextType = any, ParentType extends IResolversParentTypes['Profile'] = IResolversParentTypes['Profile']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  about?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  userpic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  followers?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  followings?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  deletedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  deleted?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IProfilePageResolvers<ContextType = any, ParentType extends IResolversParentTypes['ProfilePage'] = IResolversParentTypes['ProfilePage']> = {
+  profiles?: Resolver<Array<Maybe<IResolversTypes['Profile']>>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['Page']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchUserPortfolio?: Resolver<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>, ParentType, ContextType, RequireFields<IQueryFetchUserPortfolioArgs, 'ownerId'>>;
+  fetchAssetByBlockchain?: Resolver<IResolversTypes['Asset'], ParentType, ContextType, RequireFields<IQueryFetchAssetByBlockchainArgs, 'blockchain'>>;
+  fetchDynamicAssetData?: Resolver<IResolversTypes['DynamicAssetData'], ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetDataArgs, 'assetId'>>;
+  fetchDynamicAssetsData?: Resolver<Array<Maybe<IResolversTypes['DynamicAssetData']>>, ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetsDataArgs, 'assetIds'>>;
+  fetchAssets?: Resolver<Array<Maybe<IResolversTypes['Asset']>>, ParentType, ContextType, RequireFields<IQueryFetchAssetsArgs, 'assetIds'>>;
+  fetchAssetRank?: Resolver<IResolversTypes['AssetRank'], ParentType, ContextType, RequireFields<IQueryFetchAssetRankArgs, 'assetId'>>;
+  fetchAssetRanks?: Resolver<Array<Maybe<IResolversTypes['AssetRank']>>, ParentType, ContextType, RequireFields<IQueryFetchAssetRanksArgs, 'assetIds'>>;
+  findCollections?: Resolver<IResolversTypes['CollectionPage'], ParentType, ContextType, RequireFields<IQueryFindCollectionsArgs, 'term' | 'input'>>;
+  fetchCollection?: Resolver<IResolversTypes['Collection'], ParentType, ContextType, RequireFields<IQueryFetchCollectionArgs, 'collectionId'>>;
+  fetchCollectionsByIds?: Resolver<Array<IResolversTypes['Collection']>, ParentType, ContextType, RequireFields<IQueryFetchCollectionsByIdsArgs, 'collectionIds'>>;
+  fetchDynamicCollectionData?: Resolver<IResolversTypes['DynamicCollectionData'], ParentType, ContextType, RequireFields<IQueryFetchDynamicCollectionDataArgs, 'input'>>;
+  fetchDynamicCollectionsData?: Resolver<Array<IResolversTypes['DynamicCollectionData']>, ParentType, ContextType, RequireFields<IQueryFetchDynamicCollectionsDataArgs, 'inputs'>>;
+  findAllTopEntitiesByName?: Resolver<IResolversTypes['TopEntitiesPage'], ParentType, ContextType, RequireFields<IQueryFindAllTopEntitiesByNameArgs, 'name' | 'pageSize'>>;
+  fetchAllCreations?: Resolver<IResolversTypes['CreationsPage'], ParentType, ContextType, Partial<IQueryFetchAllCreationsArgs>>;
+  fetchCreationsByType?: Resolver<IResolversTypes['CreationsPage'], ParentType, ContextType, RequireFields<IQueryFetchCreationsByTypeArgs, 'itemType'>>;
+  findCreations?: Resolver<IResolversTypes['CreationsPage'], ParentType, ContextType, RequireFields<IQueryFindCreationsArgs, 'term' | 'input'>>;
+  findUserCreations?: Resolver<IResolversTypes['CreationsPage'], ParentType, ContextType, RequireFields<IQueryFindUserCreationsArgs, 'ownerId' | 'input'>>;
+  findProfilesByName?: Resolver<IResolversTypes['ProfilePage'], ParentType, ContextType, RequireFields<IQueryFindProfilesByNameArgs, 'name'>>;
+};
+
+export type ITopEntitiesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['TopEntitiesPage'] = IResolversParentTypes['TopEntitiesPage']> = {
+  assets?: Resolver<Array<Maybe<IResolversTypes['Asset']>>, ParentType, ContextType>;
+  collections?: Resolver<Array<Maybe<IResolversTypes['Collection']>>, ParentType, ContextType>;
+  profiles?: Resolver<Array<Maybe<IResolversTypes['Profile']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Asset?: IAssetResolvers<ContextType>;
+  AssetMarket?: IAssetMarketResolvers<ContextType>;
+  AssetRank?: IAssetRankResolvers<ContextType>;
+  AssetsPage?: IAssetsPageResolvers<ContextType>;
+  Attribute?: IAttributeResolvers<ContextType>;
+  Collection?: ICollectionResolvers<ContextType>;
+  CollectionMarket?: ICollectionMarketResolvers<ContextType>;
+  CollectionPage?: ICollectionPageResolvers<ContextType>;
+  Creation?: ICreationResolvers<ContextType>;
+  CreationsPage?: ICreationsPageResolvers<ContextType>;
+  CurrencyAmountPair?: ICurrencyAmountPairResolvers<ContextType>;
+  DynamicAssetData?: IDynamicAssetDataResolvers<ContextType>;
+  DynamicCollectionData?: IDynamicCollectionDataResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Media?: IMediaResolvers<ContextType>;
+  Mutation?: IMutationResolvers<ContextType>;
+  Page?: IPageResolvers<ContextType>;
+  Profile?: IProfileResolvers<ContextType>;
+  ProfilePage?: IProfilePageResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  TopEntitiesPage?: ITopEntitiesPageResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  NotBlank?: INotBlankDirectiveResolver<any, any, ContextType>;
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IFetchAllCreationsQueryVariables = Exact<{
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFetchAllCreationsQuery = { fetchAllCreations: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, creations: Array<Maybe<Pick<ICreation, 'id' | 'itemType' | 'itemId' | 'blockchain' | 'rank' | 'address' | 'liked' | 'likes' | 'tokenId' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType'>>> } };
+
+export type IFetchAssetByBlockchainQueryVariables = Exact<{
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type IFetchAssetByBlockchainQuery = { fetchAssetByBlockchain: (
+    Pick<IAsset, 'assetId' | 'blockchain' | 'blockchainLabel' | 'address' | 'tokenId' | 'collection' | 'id' | 'chainId' | 'blockHeight' | 'blockTimestamp' | 'name' | 'description' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'likes' | 'liked' | 'views' | 'visible' | 'createdAt' | 'blurred' | 'rank' | 'trueRank' | 'rankRaw' | 'rankMax' | 'rankUpdatedAt' | 'collectionId' | 'collectionTitle' | 'collectionOriginalUrls' | 'latestPriceBlockHeight' | 'latestPriceCurrency' | 'latestPriceAmount' | 'category' | 'categoryLabel'>
+    & { medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'originalMime' | 'hidden' | 'cover'>>>>, ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>, attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>>, collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw' | 'originalMime' | 'hidden' | 'cover'>>>>, markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+  ) };
+
+export type IFetchAssetsQueryVariables = Exact<{
+  assetIds: Array<Scalars['String']>;
+}>;
+
+
+export type IFetchAssetsQuery = { fetchAssets: Array<Maybe<(
+    Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'>
+    & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'previewUrl'>>>>, ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>> }
+  )>> };
+
+export type IFetchCollectionQueryVariables = Exact<{
+  collectionId: Scalars['String'];
+}>;
+
+
+export type IFetchCollectionQuery = { fetchCollection: (
+    Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'blockHeight' | 'blockTimestamp' | 'collectionTitle' | 'collectionUrl' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank' | 'nsfw'>
+    & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, collectionMarkets?: Maybe<Array<Maybe<Pick<ICollectionMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'username' | 'userpic'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+  ) };
+
+export type IFindCollectionsQueryVariables = Exact<{
+  term: Scalars['String'];
+  input: ICollectionFilterInput;
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFindCollectionsQuery = { findCollections: { collections: Array<Maybe<(
+      Pick<ICollection, 'collectionId' | 'collectionTitle' | 'blockchain' | 'tokenId' | 'likes' | 'liked' | 'rank'>
+      & { medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>> }
+    )>>, nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>> } };
+
+export type IFetchCollectionsByIdsQueryVariables = Exact<{
+  collectionIds: Array<Scalars['String']>;
+}>;
+
+
+export type IFetchCollectionsByIdsQuery = { fetchCollectionsByIds: Array<(
+    Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'blockHeight' | 'blockTimestamp' | 'collectionTitle' | 'collectionUrl' | 'items' | 'owners' | 'likes' | 'liked' | 'creatorsAddresses' | 'verified' | 'originalUrls' | 'rank' | 'nsfw'>
+    & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, collectionMarkets?: Maybe<Array<Maybe<Pick<ICollectionMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'username' | 'userpic'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+  )> };
+
+export type IFetchCreationsByTypeQueryVariables = Exact<{
+  itemType: Scalars['String'];
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFetchCreationsByTypeQuery = { fetchCreationsByType: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, creations: Array<Maybe<Pick<ICreation, 'id' | 'itemType' | 'itemId' | 'blockchain' | 'rank' | 'liked' | 'likes' | 'address' | 'tokenId' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType'>>> } };
+
+export type IFetchDynamicAssetLikesQueryVariables = Exact<{
+  assetId: Scalars['String'];
+}>;
+
+
+export type IFetchDynamicAssetLikesQuery = { fetchDynamicAssetData: Pick<IDynamicAssetData, 'isLikedByUser' | 'likesNum'> };
+
+export type IFetchDynamicAssetsLikesQueryVariables = Exact<{
+  assetIds: Array<Scalars['String']>;
+}>;
+
+
+export type IFetchDynamicAssetsLikesQuery = { fetchDynamicAssetsData: Array<Maybe<Pick<IDynamicAssetData, 'isLikedByUser' | 'likesNum' | 'assetId'>>> };
+
+export type IFetchDynamicCollectionDataQueryVariables = Exact<{
+  input: IDynamicCollectionDataInput;
+}>;
+
+
+export type IFetchDynamicCollectionDataQuery = { fetchDynamicCollectionData: (
+    Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'>
+    & { collectionAssetsPage?: Maybe<{ nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, assets: Array<Maybe<(
+        Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'>
+        & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'previewUrl'>>>>, ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>> }
+      )>> }> }
+  ) };
+
+export type IFetchDynamicCollectionsDataQueryVariables = Exact<{
+  input: Array<IDynamicCollectionDataInput>;
+}>;
+
+
+export type IFetchDynamicCollectionsDataQuery = { fetchDynamicCollectionsData: Array<(
+    Pick<IDynamicCollectionData, 'isLikedByUser' | 'likesNum' | 'collectionId'>
+    & { collectionAssetsPage?: Maybe<{ nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, assets: Array<Maybe<(
+        Pick<IAsset, 'latestPriceCurrency' | 'latestPriceAmount' | 'collectionId' | 'collectionOriginalUrls' | 'collectionTitle' | 'assetId' | 'blockchain' | 'address' | 'tokenId' | 'name' | 'description' | 'rank' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'views' | 'visible' | 'blurred'>
+        & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, markets?: Maybe<Array<Maybe<Pick<IAssetMarket, 'marketId' | 'marketName' | 'marketDomain' | 'marketUrl'>>>>, collectionMedias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize'>>>>, medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'previewUrl'>>>>, ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>>>, attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>> }
+      )>> }> }
+  )> };
+
+export type IFindAllTopEntitiesByNameQueryVariables = Exact<{
+  name: Scalars['String'];
+  pageSize: Scalars['Int'];
+}>;
+
+
+export type IFindAllTopEntitiesByNameQuery = { findAllTopEntitiesByName: { assets: Array<Maybe<(
+      Pick<IAsset, 'assetId' | 'address' | 'tokenId' | 'blockchain' | 'chainId' | 'blockHeight' | 'blockTimestamp' | 'name' | 'description' | 'originalUrls' | 'ownersAddresses' | 'creatorsAddresses' | 'likes' | 'views' | 'visible' | 'blurred' | 'rank' | 'rankRaw' | 'rankMax' | 'rankUpdatedAt'>
+      & { medias?: Maybe<Array<Maybe<Pick<IMedia, 'originalUrl' | 'url' | 'previewUrl' | 'mimeType' | 'sizeRatio' | 'fileSize' | 'nsfw'>>>>, ownersProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>, creatorsProfiles?: Maybe<Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>>>, attributes?: Maybe<Array<Maybe<Pick<IAttribute, 'name' | 'value'>>>> }
+    )>>, collections: Array<Maybe<(
+      Pick<ICollection, 'collectionId' | 'blockchain' | 'identifier' | 'contractAddress' | 'tokenId' | 'collectionTitle' | 'likes' | 'liked' | 'verified' | 'rank'>
+      & { totalVolumes?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>>, floorPrices?: Maybe<Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>>> }
+    )>>, profiles: Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'createdAt' | 'deletedAt' | 'visible' | 'views' | 'deleted'>>> } };
+
+export type IFetchUserPortfolioQueryVariables = Exact<{
+  ownerId: Scalars['String'];
+}>;
+
+
+export type IFetchUserPortfolioQuery = { fetchUserPortfolio: Array<Maybe<Pick<ICurrencyAmountPair, 'currency' | 'amount'>>> };
+
+export type IFindCreationsQueryVariables = Exact<{
+  term: Scalars['String'];
+  input: ICreationFilterInput;
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFindCreationsQuery = { findCreations: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, creations: Array<Maybe<Pick<ICreation, 'id' | 'itemType' | 'address' | 'tokenId' | 'itemId' | 'blockchain' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'rank' | 'likes' | 'liked'>>> } };
+
+export type IFindProfilesByNameQueryVariables = Exact<{
+  name: Scalars['String'];
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFindProfilesByNameQuery = { findProfilesByName: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, profiles: Array<Maybe<Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'followers' | 'followings' | 'visible'>>> } };
+
+export type IFindUserCreationsQueryVariables = Exact<{
+  ownerId: Scalars['String'];
+  input: ICreationFilterInput;
+  page?: Maybe<IPageInput>;
+}>;
+
+
+export type IFindUserCreationsQuery = { findUserCreations: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, creations: Array<Maybe<Pick<ICreation, 'id' | 'itemType' | 'tokenId' | 'address' | 'itemId' | 'blockchain' | 'rank' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'likes'>>> } };
+
+
+export const FetchAllCreationsDocument = gql`
+    query FetchAllCreations($page: PageInput) {
+  fetchAllCreations(page: $page) {
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+    creations {
+      id
+      itemType
+      itemId
+      blockchain
+      rank
+      address
+      liked
+      likes
+      tokenId
+      name
+      creatorsAddresses
+      originalUrls
+      media
+      mediaPreview
+      mimeType
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAllCreationsQuery__
+ *
+ * To run a query within a React component, call `useFetchAllCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAllCreationsQuery` 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 } = useFetchAllCreationsQuery({
+ *   variables: {
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAllCreationsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAllCreationsQuery, IFetchAllCreationsQueryVariables>) {
+        return Apollo.useQuery<IFetchAllCreationsQuery, IFetchAllCreationsQueryVariables>(FetchAllCreationsDocument, baseOptions);
+      }
+export function useFetchAllCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAllCreationsQuery, IFetchAllCreationsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAllCreationsQuery, IFetchAllCreationsQueryVariables>(FetchAllCreationsDocument, baseOptions);
+        }
+export type FetchAllCreationsQueryHookResult = ReturnType<typeof useFetchAllCreationsQuery>;
+export type FetchAllCreationsLazyQueryHookResult = ReturnType<typeof useFetchAllCreationsLazyQuery>;
+export type FetchAllCreationsQueryResult = Apollo.QueryResult<IFetchAllCreationsQuery, IFetchAllCreationsQueryVariables>;
+export const FetchAssetByBlockchainDocument = gql`
+    query FetchAssetByBlockchain($blockchain: String!, $address: String, $tokenId: String, $elrondId: String) {
+  fetchAssetByBlockchain(
+    blockchain: $blockchain
+    address: $address
+    tokenId: $tokenId
+    elrondId: $elrondId
+  ) {
+    assetId
+    blockchain
+    blockchainLabel
+    address
+    tokenId
+    collection
+    id
+    chainId
+    blockHeight
+    blockTimestamp
+    name
+    description
+    originalUrls
+    medias {
+      originalUrl
+      url
+      previewUrl
+      mimeType
+      sizeRatio
+      fileSize
+      nsfw
+      originalMime
+      hidden
+      cover
+    }
+    ownersAddresses
+    ownersProfiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      createdAt
+      deletedAt
+      visible
+      views
+      deleted
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      createdAt
+      deletedAt
+      visible
+      views
+      deleted
+    }
+    attributes {
+      name
+      value
+    }
+    likes
+    liked
+    views
+    visible
+    createdAt
+    blurred
+    rank
+    trueRank
+    rankRaw
+    rankMax
+    rankUpdatedAt
+    collectionId
+    collectionTitle
+    collectionOriginalUrls
+    collectionMedias {
+      originalUrl
+      url
+      previewUrl
+      mimeType
+      sizeRatio
+      fileSize
+      nsfw
+      originalMime
+      hidden
+      cover
+    }
+    markets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    latestPriceBlockHeight
+    latestPriceCurrency
+    latestPriceAmount
+    totalVolumes {
+      currency
+      amount
+    }
+    category
+    categoryLabel
+  }
+}
+    `;
+
+/**
+ * __useFetchAssetByBlockchainQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetByBlockchainQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetByBlockchainQuery` 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 } = useFetchAssetByBlockchainQuery({
+ *   variables: {
+ *      blockchain: // value for 'blockchain'
+ *      address: // value for 'address'
+ *      tokenId: // value for 'tokenId'
+ *      elrondId: // value for 'elrondId'
+ *   },
+ * });
+ */
+export function useFetchAssetByBlockchainQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>) {
+        return Apollo.useQuery<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>(FetchAssetByBlockchainDocument, baseOptions);
+      }
+export function useFetchAssetByBlockchainLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>(FetchAssetByBlockchainDocument, baseOptions);
+        }
+export type FetchAssetByBlockchainQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainQuery>;
+export type FetchAssetByBlockchainLazyQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainLazyQuery>;
+export type FetchAssetByBlockchainQueryResult = Apollo.QueryResult<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>;
+export const FetchAssetsDocument = gql`
+    query FetchAssets($assetIds: [String!]!) {
+  fetchAssets(assetIds: $assetIds) {
+    latestPriceCurrency
+    latestPriceAmount
+    collectionId
+    collectionOriginalUrls
+    collectionTitle
+    assetId
+    totalVolumes {
+      currency
+      amount
+    }
+    blockchain
+    address
+    tokenId
+    name
+    description
+    rank
+    markets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    collectionMedias {
+      originalUrl
+      url
+      previewUrl
+      mimeType
+      sizeRatio
+      fileSize
+    }
+    originalUrls
+    medias {
+      originalUrl
+      url
+      mimeType
+      sizeRatio
+      fileSize
+      previewUrl
+    }
+    ownersAddresses
+    ownersProfiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      visible
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      visible
+    }
+    attributes {
+      name
+      value
+    }
+    views
+    visible
+    blurred
+    medias {
+      originalUrl
+      url
+      previewUrl
+      mimeType
+    }
+    creatorsProfiles {
+      username
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAssetsQuery__
+ *
+ * To run a query within a React component, call `useFetchAssetsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAssetsQuery` 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 } = useFetchAssetsQuery({
+ *   variables: {
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export function useFetchAssetsQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetsQuery, IFetchAssetsQueryVariables>) {
+        return Apollo.useQuery<IFetchAssetsQuery, IFetchAssetsQueryVariables>(FetchAssetsDocument, baseOptions);
+      }
+export function useFetchAssetsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetsQuery, IFetchAssetsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAssetsQuery, IFetchAssetsQueryVariables>(FetchAssetsDocument, baseOptions);
+        }
+export type FetchAssetsQueryHookResult = ReturnType<typeof useFetchAssetsQuery>;
+export type FetchAssetsLazyQueryHookResult = ReturnType<typeof useFetchAssetsLazyQuery>;
+export type FetchAssetsQueryResult = Apollo.QueryResult<IFetchAssetsQuery, IFetchAssetsQueryVariables>;
+export const FetchCollectionDocument = gql`
+    query fetchCollection($collectionId: String!) {
+  fetchCollection(collectionId: $collectionId) {
+    collectionId
+    blockchain
+    identifier
+    contractAddress
+    tokenId
+    blockHeight
+    blockTimestamp
+    collectionTitle
+    collectionUrl
+    items
+    owners
+    totalVolumes {
+      currency
+      amount
+    }
+    likes
+    liked
+    collectionMarkets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      username
+      userpic
+    }
+    verified
+    originalUrls
+    rank
+    nsfw
+    medias {
+      originalUrl
+      url
+      mimeType
+      sizeRatio
+      fileSize
+    }
+    floorPrices {
+      currency
+      amount
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchCollectionQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionQuery` 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 } = useFetchCollectionQuery({
+ *   variables: {
+ *      collectionId: // value for 'collectionId'
+ *   },
+ * });
+ */
+export function useFetchCollectionQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
+        return Apollo.useQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
+      }
+export function useFetchCollectionLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionQuery, IFetchCollectionQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCollectionQuery, IFetchCollectionQueryVariables>(FetchCollectionDocument, baseOptions);
+        }
+export type FetchCollectionQueryHookResult = ReturnType<typeof useFetchCollectionQuery>;
+export type FetchCollectionLazyQueryHookResult = ReturnType<typeof useFetchCollectionLazyQuery>;
+export type FetchCollectionQueryResult = Apollo.QueryResult<IFetchCollectionQuery, IFetchCollectionQueryVariables>;
+export const FindCollectionsDocument = gql`
+    query FindCollections($term: String!, $input: CollectionFilterInput!, $page: PageInput) {
+  findCollections(term: $term, input: $input, page: $page) {
+    collections {
+      collectionId
+      collectionTitle
+      blockchain
+      tokenId
+      likes
+      liked
+      medias {
+        originalUrl
+        url
+        previewUrl
+        mimeType
+        sizeRatio
+        fileSize
+      }
+      rank
+    }
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+  }
+}
+    `;
+
+/**
+ * __useFindCollectionsQuery__
+ *
+ * To run a query within a React component, call `useFindCollectionsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindCollectionsQuery` 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 } = useFindCollectionsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFindCollectionsQuery(baseOptions: Apollo.QueryHookOptions<IFindCollectionsQuery, IFindCollectionsQueryVariables>) {
+        return Apollo.useQuery<IFindCollectionsQuery, IFindCollectionsQueryVariables>(FindCollectionsDocument, baseOptions);
+      }
+export function useFindCollectionsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindCollectionsQuery, IFindCollectionsQueryVariables>) {
+          return Apollo.useLazyQuery<IFindCollectionsQuery, IFindCollectionsQueryVariables>(FindCollectionsDocument, baseOptions);
+        }
+export type FindCollectionsQueryHookResult = ReturnType<typeof useFindCollectionsQuery>;
+export type FindCollectionsLazyQueryHookResult = ReturnType<typeof useFindCollectionsLazyQuery>;
+export type FindCollectionsQueryResult = Apollo.QueryResult<IFindCollectionsQuery, IFindCollectionsQueryVariables>;
+export const FetchCollectionsByIdsDocument = gql`
+    query FetchCollectionsByIds($collectionIds: [String!]!) {
+  fetchCollectionsByIds(collectionIds: $collectionIds) {
+    collectionId
+    blockchain
+    identifier
+    contractAddress
+    tokenId
+    blockHeight
+    blockTimestamp
+    collectionTitle
+    collectionUrl
+    items
+    owners
+    totalVolumes {
+      currency
+      amount
+    }
+    likes
+    liked
+    collectionMarkets {
+      marketId
+      marketName
+      marketDomain
+      marketUrl
+    }
+    creatorsAddresses
+    creatorsProfiles {
+      username
+      userpic
+    }
+    verified
+    originalUrls
+    rank
+    nsfw
+    medias {
+      originalUrl
+      url
+      mimeType
+      sizeRatio
+      fileSize
+    }
+    floorPrices {
+      currency
+      amount
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchCollectionsByIdsQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionsByIdsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionsByIdsQuery` 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 } = useFetchCollectionsByIdsQuery({
+ *   variables: {
+ *      collectionIds: // value for 'collectionIds'
+ *   },
+ * });
+ */
+export function useFetchCollectionsByIdsQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
+        return Apollo.useQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
+      }
+export function useFetchCollectionsByIdsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>(FetchCollectionsByIdsDocument, baseOptions);
+        }
+export type FetchCollectionsByIdsQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsQuery>;
+export type FetchCollectionsByIdsLazyQueryHookResult = ReturnType<typeof useFetchCollectionsByIdsLazyQuery>;
+export type FetchCollectionsByIdsQueryResult = Apollo.QueryResult<IFetchCollectionsByIdsQuery, IFetchCollectionsByIdsQueryVariables>;
+export const FetchCreationsByTypeDocument = gql`
+    query FetchCreationsByType($itemType: String!, $page: PageInput) {
+  fetchCreationsByType(itemType: $itemType, page: $page) {
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+    creations {
+      id
+      itemType
+      itemId
+      blockchain
+      rank
+      liked
+      likes
+      address
+      tokenId
+      name
+      creatorsAddresses
+      originalUrls
+      media
+      mediaPreview
+      mimeType
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchCreationsByTypeQuery__
+ *
+ * To run a query within a React component, call `useFetchCreationsByTypeQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCreationsByTypeQuery` 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 } = useFetchCreationsByTypeQuery({
+ *   variables: {
+ *      itemType: // value for 'itemType'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchCreationsByTypeQuery(baseOptions: Apollo.QueryHookOptions<IFetchCreationsByTypeQuery, IFetchCreationsByTypeQueryVariables>) {
+        return Apollo.useQuery<IFetchCreationsByTypeQuery, IFetchCreationsByTypeQueryVariables>(FetchCreationsByTypeDocument, baseOptions);
+      }
+export function useFetchCreationsByTypeLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCreationsByTypeQuery, IFetchCreationsByTypeQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCreationsByTypeQuery, IFetchCreationsByTypeQueryVariables>(FetchCreationsByTypeDocument, baseOptions);
+        }
+export type FetchCreationsByTypeQueryHookResult = ReturnType<typeof useFetchCreationsByTypeQuery>;
+export type FetchCreationsByTypeLazyQueryHookResult = ReturnType<typeof useFetchCreationsByTypeLazyQuery>;
+export type FetchCreationsByTypeQueryResult = Apollo.QueryResult<IFetchCreationsByTypeQuery, IFetchCreationsByTypeQueryVariables>;
+export const FetchDynamicAssetLikesDocument = gql`
+    query FetchDynamicAssetLikes($assetId: String!) {
+  fetchDynamicAssetData(assetId: $assetId) {
+    isLikedByUser
+    likesNum
+  }
+}
+    `;
+
+/**
+ * __useFetchDynamicAssetLikesQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicAssetLikesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicAssetLikesQuery` 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 } = useFetchDynamicAssetLikesQuery({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export function useFetchDynamicAssetLikesQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>(FetchDynamicAssetLikesDocument, baseOptions);
+      }
+export function useFetchDynamicAssetLikesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>(FetchDynamicAssetLikesDocument, baseOptions);
+        }
+export type FetchDynamicAssetLikesQueryHookResult = ReturnType<typeof useFetchDynamicAssetLikesQuery>;
+export type FetchDynamicAssetLikesLazyQueryHookResult = ReturnType<typeof useFetchDynamicAssetLikesLazyQuery>;
+export type FetchDynamicAssetLikesQueryResult = Apollo.QueryResult<IFetchDynamicAssetLikesQuery, IFetchDynamicAssetLikesQueryVariables>;
+export const FetchDynamicAssetsLikesDocument = gql`
+    query FetchDynamicAssetsLikes($assetIds: [String!]!) {
+  fetchDynamicAssetsData(assetIds: $assetIds) {
+    isLikedByUser
+    likesNum
+    assetId
+  }
+}
+    `;
+
+/**
+ * __useFetchDynamicAssetsLikesQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicAssetsLikesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicAssetsLikesQuery` 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 } = useFetchDynamicAssetsLikesQuery({
+ *   variables: {
+ *      assetIds: // value for 'assetIds'
+ *   },
+ * });
+ */
+export function useFetchDynamicAssetsLikesQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>(FetchDynamicAssetsLikesDocument, baseOptions);
+      }
+export function useFetchDynamicAssetsLikesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>(FetchDynamicAssetsLikesDocument, baseOptions);
+        }
+export type FetchDynamicAssetsLikesQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesQuery>;
+export type FetchDynamicAssetsLikesLazyQueryHookResult = ReturnType<typeof useFetchDynamicAssetsLikesLazyQuery>;
+export type FetchDynamicAssetsLikesQueryResult = Apollo.QueryResult<IFetchDynamicAssetsLikesQuery, IFetchDynamicAssetsLikesQueryVariables>;
+export const FetchDynamicCollectionDataDocument = gql`
+    query FetchDynamicCollectionData($input: DynamicCollectionDataInput!) {
+  fetchDynamicCollectionData(input: $input) {
+    isLikedByUser
+    likesNum
+    collectionId
+    collectionAssetsPage {
+      nextPage {
+        token
+        num
+        size
+        elements
+      }
+      assets {
+        latestPriceCurrency
+        latestPriceAmount
+        collectionId
+        collectionOriginalUrls
+        collectionTitle
+        assetId
+        totalVolumes {
+          currency
+          amount
+        }
+        blockchain
+        address
+        tokenId
+        name
+        description
+        rank
+        markets {
+          marketId
+          marketName
+          marketDomain
+          marketUrl
+        }
+        collectionMedias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+          sizeRatio
+          fileSize
+        }
+        originalUrls
+        medias {
+          originalUrl
+          url
+          mimeType
+          sizeRatio
+          fileSize
+          previewUrl
+        }
+        ownersAddresses
+        ownersProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        creatorsAddresses
+        creatorsProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        attributes {
+          name
+          value
+        }
+        views
+        visible
+        blurred
+        medias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+        }
+        creatorsProfiles {
+          username
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchDynamicCollectionDataQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicCollectionDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicCollectionDataQuery` 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 } = useFetchDynamicCollectionDataQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useFetchDynamicCollectionDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
+      }
+export function useFetchDynamicCollectionDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>(FetchDynamicCollectionDataDocument, baseOptions);
+        }
+export type FetchDynamicCollectionDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataQuery>;
+export type FetchDynamicCollectionDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionDataLazyQuery>;
+export type FetchDynamicCollectionDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionDataQuery, IFetchDynamicCollectionDataQueryVariables>;
+export const FetchDynamicCollectionsDataDocument = gql`
+    query FetchDynamicCollectionsData($input: [DynamicCollectionDataInput!]!) {
+  fetchDynamicCollectionsData(inputs: $input) {
+    isLikedByUser
+    likesNum
+    collectionId
+    collectionAssetsPage {
+      nextPage {
+        token
+        num
+        size
+        elements
+      }
+      assets {
+        latestPriceCurrency
+        latestPriceAmount
+        collectionId
+        collectionOriginalUrls
+        collectionTitle
+        assetId
+        totalVolumes {
+          currency
+          amount
+        }
+        blockchain
+        address
+        tokenId
+        name
+        description
+        rank
+        markets {
+          marketId
+          marketName
+          marketDomain
+          marketUrl
+        }
+        collectionMedias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+          sizeRatio
+          fileSize
+        }
+        originalUrls
+        medias {
+          originalUrl
+          url
+          mimeType
+          sizeRatio
+          fileSize
+          previewUrl
+        }
+        ownersAddresses
+        ownersProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        creatorsAddresses
+        creatorsProfiles {
+          userId
+          username
+          about
+          userpic
+          followers
+          followings
+          visible
+        }
+        attributes {
+          name
+          value
+        }
+        views
+        visible
+        blurred
+        medias {
+          originalUrl
+          url
+          previewUrl
+          mimeType
+        }
+        creatorsProfiles {
+          username
+        }
+      }
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchDynamicCollectionsDataQuery__
+ *
+ * To run a query within a React component, call `useFetchDynamicCollectionsDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchDynamicCollectionsDataQuery` 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 } = useFetchDynamicCollectionsDataQuery({
+ *   variables: {
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useFetchDynamicCollectionsDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
+        return Apollo.useQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
+      }
+export function useFetchDynamicCollectionsDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>(FetchDynamicCollectionsDataDocument, baseOptions);
+        }
+export type FetchDynamicCollectionsDataQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataQuery>;
+export type FetchDynamicCollectionsDataLazyQueryHookResult = ReturnType<typeof useFetchDynamicCollectionsDataLazyQuery>;
+export type FetchDynamicCollectionsDataQueryResult = Apollo.QueryResult<IFetchDynamicCollectionsDataQuery, IFetchDynamicCollectionsDataQueryVariables>;
+export const FindAllTopEntitiesByNameDocument = gql`
+    query FindAllTopEntitiesByName($name: String!, $pageSize: Int!) {
+  findAllTopEntitiesByName(name: $name, pageSize: $pageSize) {
+    assets {
+      assetId
+      address
+      tokenId
+      blockchain
+      chainId
+      blockHeight
+      blockTimestamp
+      name
+      description
+      originalUrls
+      medias {
+        originalUrl
+        url
+        previewUrl
+        mimeType
+        sizeRatio
+        fileSize
+        nsfw
+      }
+      ownersAddresses
+      ownersProfiles {
+        userId
+        username
+        about
+        userpic
+        followers
+        followings
+        createdAt
+        deletedAt
+        visible
+        views
+        deleted
+      }
+      creatorsAddresses
+      creatorsProfiles {
+        userId
+        username
+        about
+        userpic
+        followers
+        followings
+        createdAt
+        deletedAt
+        visible
+        views
+        deleted
+      }
+      attributes {
+        name
+        value
+      }
+      likes
+      views
+      visible
+      blurred
+      rank
+      rankRaw
+      rankMax
+      rankUpdatedAt
+    }
+    collections {
+      collectionId
+      blockchain
+      identifier
+      contractAddress
+      tokenId
+      collectionTitle
+      totalVolumes {
+        currency
+        amount
+      }
+      likes
+      liked
+      verified
+      rank
+      floorPrices {
+        currency
+        amount
+      }
+    }
+    profiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      createdAt
+      deletedAt
+      visible
+      views
+      deleted
+    }
+  }
+}
+    `;
+
+/**
+ * __useFindAllTopEntitiesByNameQuery__
+ *
+ * To run a query within a React component, call `useFindAllTopEntitiesByNameQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindAllTopEntitiesByNameQuery` 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 } = useFindAllTopEntitiesByNameQuery({
+ *   variables: {
+ *      name: // value for 'name'
+ *      pageSize: // value for 'pageSize'
+ *   },
+ * });
+ */
+export function useFindAllTopEntitiesByNameQuery(baseOptions: Apollo.QueryHookOptions<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>) {
+        return Apollo.useQuery<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>(FindAllTopEntitiesByNameDocument, baseOptions);
+      }
+export function useFindAllTopEntitiesByNameLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>) {
+          return Apollo.useLazyQuery<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>(FindAllTopEntitiesByNameDocument, baseOptions);
+        }
+export type FindAllTopEntitiesByNameQueryHookResult = ReturnType<typeof useFindAllTopEntitiesByNameQuery>;
+export type FindAllTopEntitiesByNameLazyQueryHookResult = ReturnType<typeof useFindAllTopEntitiesByNameLazyQuery>;
+export type FindAllTopEntitiesByNameQueryResult = Apollo.QueryResult<IFindAllTopEntitiesByNameQuery, IFindAllTopEntitiesByNameQueryVariables>;
+export const FetchUserPortfolioDocument = gql`
+    query FetchUserPortfolio($ownerId: String!) {
+  fetchUserPortfolio(ownerId: $ownerId) {
+    currency
+    amount
+  }
+}
+    `;
+
+/**
+ * __useFetchUserPortfolioQuery__
+ *
+ * To run a query within a React component, call `useFetchUserPortfolioQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserPortfolioQuery` 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 } = useFetchUserPortfolioQuery({
+ *   variables: {
+ *      ownerId: // value for 'ownerId'
+ *   },
+ * });
+ */
+export function useFetchUserPortfolioQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>) {
+        return Apollo.useQuery<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>(FetchUserPortfolioDocument, baseOptions);
+      }
+export function useFetchUserPortfolioLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>(FetchUserPortfolioDocument, baseOptions);
+        }
+export type FetchUserPortfolioQueryHookResult = ReturnType<typeof useFetchUserPortfolioQuery>;
+export type FetchUserPortfolioLazyQueryHookResult = ReturnType<typeof useFetchUserPortfolioLazyQuery>;
+export type FetchUserPortfolioQueryResult = Apollo.QueryResult<IFetchUserPortfolioQuery, IFetchUserPortfolioQueryVariables>;
+export const FindCreationsDocument = gql`
+    query FindCreations($term: String!, $input: CreationFilterInput!, $page: PageInput) {
+  findCreations(term: $term, input: $input, page: $page) {
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+    creations {
+      id
+      itemType
+      address
+      tokenId
+      itemId
+      blockchain
+      name
+      creatorsAddresses
+      originalUrls
+      media
+      mediaPreview
+      mimeType
+      rank
+      likes
+      liked
+    }
+  }
+}
+    `;
+
+/**
+ * __useFindCreationsQuery__
+ *
+ * To run a query within a React component, call `useFindCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindCreationsQuery` 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 } = useFindCreationsQuery({
+ *   variables: {
+ *      term: // value for 'term'
+ *      input: // value for 'input'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFindCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFindCreationsQuery, IFindCreationsQueryVariables>) {
+        return Apollo.useQuery<IFindCreationsQuery, IFindCreationsQueryVariables>(FindCreationsDocument, baseOptions);
+      }
+export function useFindCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindCreationsQuery, IFindCreationsQueryVariables>) {
+          return Apollo.useLazyQuery<IFindCreationsQuery, IFindCreationsQueryVariables>(FindCreationsDocument, baseOptions);
+        }
+export type FindCreationsQueryHookResult = ReturnType<typeof useFindCreationsQuery>;
+export type FindCreationsLazyQueryHookResult = ReturnType<typeof useFindCreationsLazyQuery>;
+export type FindCreationsQueryResult = Apollo.QueryResult<IFindCreationsQuery, IFindCreationsQueryVariables>;
+export const FindProfilesByNameDocument = gql`
+    query FindProfilesByName($name: String!, $page: PageInput) {
+  findProfilesByName(name: $name, page: $page) {
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+    profiles {
+      userId
+      username
+      about
+      userpic
+      followers
+      followings
+      visible
+    }
+  }
+}
+    `;
+
+/**
+ * __useFindProfilesByNameQuery__
+ *
+ * To run a query within a React component, call `useFindProfilesByNameQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindProfilesByNameQuery` 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 } = useFindProfilesByNameQuery({
+ *   variables: {
+ *      name: // value for 'name'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFindProfilesByNameQuery(baseOptions: Apollo.QueryHookOptions<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>) {
+        return Apollo.useQuery<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>(FindProfilesByNameDocument, baseOptions);
+      }
+export function useFindProfilesByNameLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>) {
+          return Apollo.useLazyQuery<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>(FindProfilesByNameDocument, baseOptions);
+        }
+export type FindProfilesByNameQueryHookResult = ReturnType<typeof useFindProfilesByNameQuery>;
+export type FindProfilesByNameLazyQueryHookResult = ReturnType<typeof useFindProfilesByNameLazyQuery>;
+export type FindProfilesByNameQueryResult = Apollo.QueryResult<IFindProfilesByNameQuery, IFindProfilesByNameQueryVariables>;
+export const FindUserCreationsDocument = gql`
+    query FindUserCreations($ownerId: String!, $input: CreationFilterInput!, $page: PageInput) {
+  findUserCreations(ownerId: $ownerId, input: $input, page: $page) {
+    nextPage {
+      token
+      num
+      size
+      elements
+    }
+    creations {
+      id
+      id
+      itemType
+      tokenId
+      address
+      itemId
+      blockchain
+      rank
+      name
+      creatorsAddresses
+      originalUrls
+      media
+      mediaPreview
+      mimeType
+      likes
+    }
+  }
+}
+    `;
+
+/**
+ * __useFindUserCreationsQuery__
+ *
+ * To run a query within a React component, call `useFindUserCreationsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFindUserCreationsQuery` 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 } = useFindUserCreationsQuery({
+ *   variables: {
+ *      ownerId: // value for 'ownerId'
+ *      input: // value for 'input'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFindUserCreationsQuery(baseOptions: Apollo.QueryHookOptions<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>) {
+        return Apollo.useQuery<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>(FindUserCreationsDocument, baseOptions);
+      }
+export function useFindUserCreationsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>) {
+          return Apollo.useLazyQuery<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>(FindUserCreationsDocument, baseOptions);
+        }
+export type FindUserCreationsQueryHookResult = ReturnType<typeof useFindUserCreationsQuery>;
+export type FindUserCreationsLazyQueryHookResult = ReturnType<typeof useFindUserCreationsLazyQuery>;
+export type FindUserCreationsQueryResult = Apollo.QueryResult<IFindUserCreationsQuery, IFindUserCreationsQueryVariables>;