@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,1074 @@
+/* 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;
+  /** A 64-bit signed integer */
+  Long: any;
+};
+
+
+export type IAssetData = {
+  assetId: Scalars['String'];
+  rank?: Maybe<Scalars['Float']>;
+};
+
+export type IBrand = {
+  brandId: Scalars['ID'];
+  name: Scalars['String'];
+  matchingWords: Array<Maybe<Scalars['String']>>;
+  description?: Maybe<Scalars['String']>;
+  industry?: Maybe<Scalars['String']>;
+  link?: Maybe<Scalars['String']>;
+  media?: Maybe<Scalars['String']>;
+};
+
+export type ICategory = {
+  categoryId: Scalars['ID'];
+  name: Scalars['String'];
+  matchingWords: Array<Maybe<Scalars['String']>>;
+};
+
+export type ICollectionData = {
+  collectionId: Scalars['String'];
+  title?: Maybe<Scalars['String']>;
+  rank?: Maybe<Scalars['Float']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  itemsNum?: Maybe<Scalars['String']>;
+  holdersNum?: Maybe<Scalars['String']>;
+  floorPrice?: Maybe<Scalars['Float']>;
+  coverS3Key?: Maybe<Scalars['String']>;
+  videoCoverS3Key?: Maybe<Scalars['String']>;
+};
+
+export type ICollectionKey = {
+  blockchain: Scalars['String'];
+  contractAddress?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+};
+
+export type ICollectionRank = {
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+  rank?: Maybe<Scalars['Float']>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  visitPage: Array<Maybe<IOpportunity>>;
+  visitPageV2?: Maybe<IOpportunityV2>;
+  openOpportunityV2: Scalars['Boolean'];
+  hideOpportunityV2: Scalars['Boolean'];
+  clearCaches: Scalars['Boolean'];
+};
+
+
+export type IMutationVisitPageArgs = {
+  domain: Scalars['String'];
+  title: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+  category?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationVisitPageV2Args = {
+  domain: Scalars['String'];
+  title: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+  brandId?: Maybe<Scalars['String']>;
+  category?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationOpenOpportunityV2Args = {
+  opportunityId: Scalars['ID'];
+};
+
+
+export type IMutationHideOpportunityV2Args = {
+  opportunityId: Scalars['ID'];
+};
+
+export type INftData = {
+  blockchain: Scalars['String'];
+  contractAddress?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+  collectionData?: Maybe<ICollectionData>;
+  assetData?: Maybe<IAssetData>;
+  userRank?: Maybe<Scalars['Float']>;
+};
+
+export type INftKey = {
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+};
+
+export type INftRank = {
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  rank?: Maybe<Scalars['Float']>;
+};
+
+export type IOpportunitiesPageV2 = {
+  currentOpportunities?: Maybe<Array<Maybe<IOpportunityV2>>>;
+  similarOpportunities?: Maybe<Array<Maybe<IOpportunityV2>>>;
+};
+
+export type IOpportunity = {
+  opportunityId?: Maybe<Scalars['ID']>;
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  startedAt?: Maybe<Scalars['Long']>;
+  endedAt?: Maybe<Scalars['Long']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+  category?: Maybe<Scalars['String']>;
+  media?: Maybe<Scalars['String']>;
+  links?: Maybe<Array<Maybe<Scalars['String']>>>;
+  ludoRankRequired?: Maybe<Scalars['Boolean']>;
+  ludoRankRequiredMin?: Maybe<Scalars['Int']>;
+  ludoRankRequiredMax?: Maybe<Scalars['Int']>;
+  rewardType?: Maybe<Scalars['String']>;
+  creatorId?: Maybe<Scalars['String']>;
+  creatorWallet?: Maybe<Scalars['String']>;
+  status?: Maybe<Scalars['String']>;
+  shareLink?: Maybe<Scalars['String']>;
+  notifiable?: Maybe<Scalars['Boolean']>;
+  brandId?: Maybe<Scalars['String']>;
+  brandName?: Maybe<Scalars['String']>;
+  brandDescription?: Maybe<Scalars['String']>;
+  brandIndustry?: Maybe<Scalars['String']>;
+  brandLink?: Maybe<Scalars['String']>;
+  brandMedia?: Maybe<Scalars['String']>;
+};
+
+export type IOpportunityV2 = {
+  opportunityId?: Maybe<Scalars['ID']>;
+  brandId?: Maybe<Scalars['String']>;
+  categoryId?: Maybe<Scalars['String']>;
+  opportunityStatus?: Maybe<Scalars['String']>;
+  opportunityType?: Maybe<Scalars['String']>;
+  notificationType?: Maybe<Scalars['String']>;
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  brandName?: Maybe<Scalars['String']>;
+  brandDescription?: Maybe<Scalars['String']>;
+  brandMedia?: Maybe<Scalars['String']>;
+  brandUrl?: Maybe<Scalars['String']>;
+  brandIndustry?: Maybe<Scalars['String']>;
+  categoryName?: Maybe<Scalars['String']>;
+  ludoUrl?: Maybe<Scalars['String']>;
+  projectUrl?: Maybe<Scalars['String']>;
+  activeFrom?: Maybe<Scalars['Long']>;
+  activeUntil?: Maybe<Scalars['Long']>;
+  media?: Maybe<Scalars['String']>;
+  reportLink?: Maybe<Scalars['String']>;
+  shareLink?: Maybe<Scalars['String']>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchNFTData: INftData;
+  fetchCollectionsData: Array<ICollectionData>;
+  fetchNFTRanks: Array<INftRank>;
+  fetchCollectionRanks: Array<ICollectionRank>;
+  fetchWalletRanks: Array<IWalletRank>;
+  fetchExtensionBrands: Array<Maybe<IBrand>>;
+  fetchExtensionCategories: Array<Maybe<ICategory>>;
+  fetchExtensionOpportunitiesV2: IOpportunitiesPageV2;
+};
+
+
+export type IQueryFetchNftDataArgs = {
+  blockchain: Scalars['String'];
+  contractAddress?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+};
+
+
+export type IQueryFetchCollectionsDataArgs = {
+  collectionKeys: Array<ICollectionKey>;
+};
+
+
+export type IQueryFetchNftRanksArgs = {
+  nftKeys: Array<INftKey>;
+};
+
+
+export type IQueryFetchCollectionRanksArgs = {
+  collectionKeys: Array<ICollectionKey>;
+};
+
+
+export type IQueryFetchWalletRanksArgs = {
+  wallets: Array<Scalars['String']>;
+};
+
+
+export type IQueryFetchExtensionOpportunitiesV2Args = {
+  domain: Scalars['String'];
+  brandId?: Maybe<Scalars['String']>;
+  categoryId?: Maybe<Scalars['String']>;
+};
+
+export type IWalletRank = {
+  wallet: Scalars['String'];
+  rank?: Maybe<Scalars['Float']>;
+};
+
+
+
+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 = {
+  AssetData: ResolverTypeWrapper<IAssetData>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  Brand: ResolverTypeWrapper<IBrand>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  Category: ResolverTypeWrapper<ICategory>;
+  CollectionData: ResolverTypeWrapper<ICollectionData>;
+  CollectionKey: ICollectionKey;
+  CollectionRank: ResolverTypeWrapper<ICollectionRank>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  NFTData: ResolverTypeWrapper<INftData>;
+  NFTKey: INftKey;
+  NFTRank: ResolverTypeWrapper<INftRank>;
+  OpportunitiesPageV2: ResolverTypeWrapper<IOpportunitiesPageV2>;
+  Opportunity: ResolverTypeWrapper<IOpportunity>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  OpportunityV2: ResolverTypeWrapper<IOpportunityV2>;
+  Query: ResolverTypeWrapper<{}>;
+  WalletRank: ResolverTypeWrapper<IWalletRank>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  AssetData: IAssetData;
+  String: Scalars['String'];
+  Float: Scalars['Float'];
+  Brand: IBrand;
+  ID: Scalars['ID'];
+  Category: ICategory;
+  CollectionData: ICollectionData;
+  CollectionKey: ICollectionKey;
+  CollectionRank: ICollectionRank;
+  Long: Scalars['Long'];
+  Mutation: {};
+  Boolean: Scalars['Boolean'];
+  NFTData: INftData;
+  NFTKey: INftKey;
+  NFTRank: INftRank;
+  OpportunitiesPageV2: IOpportunitiesPageV2;
+  Opportunity: IOpportunity;
+  Int: Scalars['Int'];
+  OpportunityV2: IOpportunityV2;
+  Query: {};
+  WalletRank: IWalletRank;
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IAssetDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetData'] = IResolversParentTypes['AssetData']> = {
+  assetId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IBrandResolvers<ContextType = any, ParentType extends IResolversParentTypes['Brand'] = IResolversParentTypes['Brand']> = {
+  brandId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  matchingWords?: Resolver<Array<Maybe<IResolversTypes['String']>>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  industry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  link?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICategoryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Category'] = IResolversParentTypes['Category']> = {
+  categoryId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  matchingWords?: Resolver<Array<Maybe<IResolversTypes['String']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICollectionDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['CollectionData'] = IResolversParentTypes['CollectionData']> = {
+  collectionId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  title?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  itemsNum?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  holdersNum?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  floorPrice?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  coverS3Key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  videoCoverS3Key?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICollectionRankResolvers<ContextType = any, ParentType extends IResolversParentTypes['CollectionRank'] = IResolversParentTypes['CollectionRank']> = {
+  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>;
+  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
+  name: 'Long';
+}
+
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  visitPage?: Resolver<Array<Maybe<IResolversTypes['Opportunity']>>, ParentType, ContextType, RequireFields<IMutationVisitPageArgs, 'domain' | 'title'>>;
+  visitPageV2?: Resolver<Maybe<IResolversTypes['OpportunityV2']>, ParentType, ContextType, RequireFields<IMutationVisitPageV2Args, 'domain' | 'title'>>;
+  openOpportunityV2?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationOpenOpportunityV2Args, 'opportunityId'>>;
+  hideOpportunityV2?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationHideOpportunityV2Args, 'opportunityId'>>;
+  clearCaches?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+};
+
+export type INftDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['NFTData'] = IResolversParentTypes['NFTData']> = {
+  blockchain?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  contractAddress?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  elrondId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionData?: Resolver<Maybe<IResolversTypes['CollectionData']>, ParentType, ContextType>;
+  assetData?: Resolver<Maybe<IResolversTypes['AssetData']>, ParentType, ContextType>;
+  userRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type INftRankResolvers<ContextType = any, ParentType extends IResolversParentTypes['NFTRank'] = IResolversParentTypes['NFTRank']> = {
+  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>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IOpportunitiesPageV2Resolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunitiesPageV2'] = IResolversParentTypes['OpportunitiesPageV2']> = {
+  currentOpportunities?: Resolver<Maybe<Array<Maybe<IResolversTypes['OpportunityV2']>>>, ParentType, ContextType>;
+  similarOpportunities?: Resolver<Maybe<Array<Maybe<IResolversTypes['OpportunityV2']>>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IOpportunityResolvers<ContextType = any, ParentType extends IResolversParentTypes['Opportunity'] = IResolversParentTypes['Opportunity']> = {
+  opportunityId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  startedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  endedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  tags?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  links?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  ludoRankRequired?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  ludoRankRequiredMin?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  ludoRankRequiredMax?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  rewardType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  creatorId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  creatorWallet?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  shareLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  notifiable?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  brandId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandIndustry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandMedia?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IOpportunityV2Resolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunityV2'] = IResolversParentTypes['OpportunityV2']> = {
+  opportunityId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+  brandId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  categoryId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  opportunityStatus?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  opportunityType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  notificationType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandDescription?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandMedia?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandIndustry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  categoryName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  ludoUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  projectUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  activeFrom?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  activeUntil?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  reportLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  shareLink?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchNFTData?: Resolver<IResolversTypes['NFTData'], ParentType, ContextType, RequireFields<IQueryFetchNftDataArgs, 'blockchain'>>;
+  fetchCollectionsData?: Resolver<Array<IResolversTypes['CollectionData']>, ParentType, ContextType, RequireFields<IQueryFetchCollectionsDataArgs, 'collectionKeys'>>;
+  fetchNFTRanks?: Resolver<Array<IResolversTypes['NFTRank']>, ParentType, ContextType, RequireFields<IQueryFetchNftRanksArgs, 'nftKeys'>>;
+  fetchCollectionRanks?: Resolver<Array<IResolversTypes['CollectionRank']>, ParentType, ContextType, RequireFields<IQueryFetchCollectionRanksArgs, 'collectionKeys'>>;
+  fetchWalletRanks?: Resolver<Array<IResolversTypes['WalletRank']>, ParentType, ContextType, RequireFields<IQueryFetchWalletRanksArgs, 'wallets'>>;
+  fetchExtensionBrands?: Resolver<Array<Maybe<IResolversTypes['Brand']>>, ParentType, ContextType>;
+  fetchExtensionCategories?: Resolver<Array<Maybe<IResolversTypes['Category']>>, ParentType, ContextType>;
+  fetchExtensionOpportunitiesV2?: Resolver<IResolversTypes['OpportunitiesPageV2'], ParentType, ContextType, RequireFields<IQueryFetchExtensionOpportunitiesV2Args, 'domain'>>;
+};
+
+export type IWalletRankResolvers<ContextType = any, ParentType extends IResolversParentTypes['WalletRank'] = IResolversParentTypes['WalletRank']> = {
+  wallet?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  AssetData?: IAssetDataResolvers<ContextType>;
+  Brand?: IBrandResolvers<ContextType>;
+  Category?: ICategoryResolvers<ContextType>;
+  CollectionData?: ICollectionDataResolvers<ContextType>;
+  CollectionRank?: ICollectionRankResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  NFTData?: INftDataResolvers<ContextType>;
+  NFTRank?: INftRankResolvers<ContextType>;
+  OpportunitiesPageV2?: IOpportunitiesPageV2Resolvers<ContextType>;
+  Opportunity?: IOpportunityResolvers<ContextType>;
+  OpportunityV2?: IOpportunityV2Resolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  WalletRank?: IWalletRankResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IHideOpportunityV2MutationVariables = Exact<{
+  opportunityId: Scalars['ID'];
+}>;
+
+
+export type IHideOpportunityV2Mutation = Pick<IMutation, 'hideOpportunityV2'>;
+
+export type IOpenOpportunityV2MutationVariables = Exact<{
+  opportunityId: Scalars['ID'];
+}>;
+
+
+export type IOpenOpportunityV2Mutation = Pick<IMutation, 'openOpportunityV2'>;
+
+export type IVisitPageV2MutationVariables = Exact<{
+  domain: Scalars['String'];
+  title: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  tags?: Maybe<Array<Maybe<Scalars['String']>>>;
+  brandId?: Maybe<Scalars['String']>;
+  category?: Maybe<Scalars['String']>;
+}>;
+
+
+export type IVisitPageV2Mutation = { visitPageV2?: Maybe<Pick<IOpportunityV2, 'opportunityId' | 'brandId' | 'categoryId' | 'opportunityStatus' | 'opportunityType' | 'notificationType' | 'name' | 'brandName' | 'brandDescription' | 'brandMedia' | 'brandUrl' | 'brandIndustry' | 'categoryName' | 'description' | 'ludoUrl' | 'projectUrl' | 'activeFrom' | 'activeUntil' | 'media' | 'reportLink' | 'shareLink'>> };
+
+export type IFetchCollectionRanksQueryVariables = Exact<{
+  collectionKeys: Array<ICollectionKey>;
+}>;
+
+
+export type IFetchCollectionRanksQuery = { fetchCollectionRanks: Array<Pick<ICollectionRank, 'blockchain' | 'address' | 'tokenId' | 'id' | 'collectionTitle' | 'rank'>> };
+
+export type IFetchExtensionBrandsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchExtensionBrandsQuery = { fetchExtensionBrands: Array<Maybe<Pick<IBrand, 'brandId' | 'name' | 'matchingWords' | 'description' | 'industry' | 'link' | 'media'>>> };
+
+export type IFetchExtensionCategoriesQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchExtensionCategoriesQuery = { fetchExtensionCategories: Array<Maybe<Pick<ICategory, 'categoryId' | 'name' | 'matchingWords'>>> };
+
+export type IFetchExtensionOpportunitiesV2QueryVariables = Exact<{
+  domain: Scalars['String'];
+  brandId?: Maybe<Scalars['String']>;
+  categoryId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type IFetchExtensionOpportunitiesV2Query = { fetchExtensionOpportunitiesV2: { currentOpportunities?: Maybe<Array<Maybe<Pick<IOpportunityV2, 'opportunityId' | 'brandId' | 'categoryId' | 'opportunityStatus' | 'opportunityType' | 'notificationType' | 'name' | 'brandName' | 'brandDescription' | 'brandMedia' | 'brandUrl' | 'brandIndustry' | 'categoryName' | 'description' | 'ludoUrl' | 'projectUrl' | 'activeFrom' | 'activeUntil' | 'media' | 'reportLink' | 'shareLink'>>>>, similarOpportunities?: Maybe<Array<Maybe<Pick<IOpportunityV2, 'opportunityId' | 'brandId' | 'categoryId' | 'opportunityStatus' | 'opportunityType' | 'notificationType' | 'name' | 'brandName' | 'brandDescription' | 'brandMedia' | 'brandUrl' | 'brandIndustry' | 'categoryName' | 'description' | 'ludoUrl' | 'projectUrl' | 'activeFrom' | 'activeUntil' | 'media' | 'reportLink' | 'shareLink'>>>> } };
+
+export type IFetchNftDataQueryVariables = Exact<{
+  blockchain: Scalars['String'];
+  contractAddress?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type IFetchNftDataQuery = { fetchNFTData: (
+    Pick<INftData, 'blockchain' | 'contractAddress' | 'tokenId' | 'elrondId' | 'userRank'>
+    & { collectionData?: Maybe<Pick<ICollectionData, 'collectionId' | 'title' | 'rank' | 'createdAt' | 'itemsNum' | 'holdersNum' | 'floorPrice'>>, assetData?: Maybe<Pick<IAssetData, 'assetId' | 'rank'>> }
+  ) };
+
+export type IFetchNftRanksQueryVariables = Exact<{
+  nftKeys: Array<INftKey>;
+}>;
+
+
+export type IFetchNftRanksQuery = { fetchNFTRanks: Array<Pick<INftRank, 'blockchain' | 'address' | 'tokenId' | 'id' | 'rank'>> };
+
+export type IFetchWalletRanksQueryVariables = Exact<{
+  wallets: Array<Scalars['String']>;
+}>;
+
+
+export type IFetchWalletRanksQuery = { fetchWalletRanks: Array<Pick<IWalletRank, 'wallet' | 'rank'>> };
+
+
+export const HideOpportunityV2Document = gql`
+    mutation HideOpportunityV2($opportunityId: ID!) {
+  hideOpportunityV2(opportunityId: $opportunityId)
+}
+    `;
+export type IHideOpportunityV2MutationFn = Apollo.MutationFunction<IHideOpportunityV2Mutation, IHideOpportunityV2MutationVariables>;
+
+/**
+ * __useHideOpportunityV2Mutation__
+ *
+ * To run a mutation, you first call `useHideOpportunityV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useHideOpportunityV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [hideOpportunityV2Mutation, { data, loading, error }] = useHideOpportunityV2Mutation({
+ *   variables: {
+ *      opportunityId: // value for 'opportunityId'
+ *   },
+ * });
+ */
+export function useHideOpportunityV2Mutation(baseOptions?: Apollo.MutationHookOptions<IHideOpportunityV2Mutation, IHideOpportunityV2MutationVariables>) {
+        return Apollo.useMutation<IHideOpportunityV2Mutation, IHideOpportunityV2MutationVariables>(HideOpportunityV2Document, baseOptions);
+      }
+export type HideOpportunityV2MutationHookResult = ReturnType<typeof useHideOpportunityV2Mutation>;
+export type HideOpportunityV2MutationResult = Apollo.MutationResult<IHideOpportunityV2Mutation>;
+export type HideOpportunityV2MutationOptions = Apollo.BaseMutationOptions<IHideOpportunityV2Mutation, IHideOpportunityV2MutationVariables>;
+export const OpenOpportunityV2Document = gql`
+    mutation OpenOpportunityV2($opportunityId: ID!) {
+  openOpportunityV2(opportunityId: $opportunityId)
+}
+    `;
+export type IOpenOpportunityV2MutationFn = Apollo.MutationFunction<IOpenOpportunityV2Mutation, IOpenOpportunityV2MutationVariables>;
+
+/**
+ * __useOpenOpportunityV2Mutation__
+ *
+ * To run a mutation, you first call `useOpenOpportunityV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useOpenOpportunityV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [openOpportunityV2Mutation, { data, loading, error }] = useOpenOpportunityV2Mutation({
+ *   variables: {
+ *      opportunityId: // value for 'opportunityId'
+ *   },
+ * });
+ */
+export function useOpenOpportunityV2Mutation(baseOptions?: Apollo.MutationHookOptions<IOpenOpportunityV2Mutation, IOpenOpportunityV2MutationVariables>) {
+        return Apollo.useMutation<IOpenOpportunityV2Mutation, IOpenOpportunityV2MutationVariables>(OpenOpportunityV2Document, baseOptions);
+      }
+export type OpenOpportunityV2MutationHookResult = ReturnType<typeof useOpenOpportunityV2Mutation>;
+export type OpenOpportunityV2MutationResult = Apollo.MutationResult<IOpenOpportunityV2Mutation>;
+export type OpenOpportunityV2MutationOptions = Apollo.BaseMutationOptions<IOpenOpportunityV2Mutation, IOpenOpportunityV2MutationVariables>;
+export const VisitPageV2Document = gql`
+    mutation VisitPageV2($domain: String!, $title: String!, $description: String, $tags: [String], $brandId: String, $category: String) {
+  visitPageV2(
+    domain: $domain
+    title: $title
+    description: $description
+    tags: $tags
+    brandId: $brandId
+    category: $category
+  ) {
+    opportunityId
+    brandId
+    categoryId
+    opportunityStatus
+    opportunityType
+    notificationType
+    name
+    brandName
+    brandDescription
+    brandMedia
+    brandUrl
+    brandIndustry
+    categoryName
+    description
+    ludoUrl
+    projectUrl
+    activeFrom
+    activeUntil
+    media
+    reportLink
+    shareLink
+  }
+}
+    `;
+export type IVisitPageV2MutationFn = Apollo.MutationFunction<IVisitPageV2Mutation, IVisitPageV2MutationVariables>;
+
+/**
+ * __useVisitPageV2Mutation__
+ *
+ * To run a mutation, you first call `useVisitPageV2Mutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useVisitPageV2Mutation` returns a tuple that includes:
+ * - A mutate function that you can call at any time to execute the mutation
+ * - An object with fields that represent the current status of the mutation's execution
+ *
+ * @param baseOptions options that will be passed into the mutation, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options-2;
+ *
+ * @example
+ * const [visitPageV2Mutation, { data, loading, error }] = useVisitPageV2Mutation({
+ *   variables: {
+ *      domain: // value for 'domain'
+ *      title: // value for 'title'
+ *      description: // value for 'description'
+ *      tags: // value for 'tags'
+ *      brandId: // value for 'brandId'
+ *      category: // value for 'category'
+ *   },
+ * });
+ */
+export function useVisitPageV2Mutation(baseOptions?: Apollo.MutationHookOptions<IVisitPageV2Mutation, IVisitPageV2MutationVariables>) {
+        return Apollo.useMutation<IVisitPageV2Mutation, IVisitPageV2MutationVariables>(VisitPageV2Document, baseOptions);
+      }
+export type VisitPageV2MutationHookResult = ReturnType<typeof useVisitPageV2Mutation>;
+export type VisitPageV2MutationResult = Apollo.MutationResult<IVisitPageV2Mutation>;
+export type VisitPageV2MutationOptions = Apollo.BaseMutationOptions<IVisitPageV2Mutation, IVisitPageV2MutationVariables>;
+export const FetchCollectionRanksDocument = gql`
+    query FetchCollectionRanks($collectionKeys: [CollectionKey!]!) {
+  fetchCollectionRanks(collectionKeys: $collectionKeys) {
+    blockchain
+    address
+    tokenId
+    id
+    collectionTitle
+    rank
+  }
+}
+    `;
+
+/**
+ * __useFetchCollectionRanksQuery__
+ *
+ * To run a query within a React component, call `useFetchCollectionRanksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchCollectionRanksQuery` 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 } = useFetchCollectionRanksQuery({
+ *   variables: {
+ *      collectionKeys: // value for 'collectionKeys'
+ *   },
+ * });
+ */
+export function useFetchCollectionRanksQuery(baseOptions: Apollo.QueryHookOptions<IFetchCollectionRanksQuery, IFetchCollectionRanksQueryVariables>) {
+        return Apollo.useQuery<IFetchCollectionRanksQuery, IFetchCollectionRanksQueryVariables>(FetchCollectionRanksDocument, baseOptions);
+      }
+export function useFetchCollectionRanksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchCollectionRanksQuery, IFetchCollectionRanksQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchCollectionRanksQuery, IFetchCollectionRanksQueryVariables>(FetchCollectionRanksDocument, baseOptions);
+        }
+export type FetchCollectionRanksQueryHookResult = ReturnType<typeof useFetchCollectionRanksQuery>;
+export type FetchCollectionRanksLazyQueryHookResult = ReturnType<typeof useFetchCollectionRanksLazyQuery>;
+export type FetchCollectionRanksQueryResult = Apollo.QueryResult<IFetchCollectionRanksQuery, IFetchCollectionRanksQueryVariables>;
+export const FetchExtensionBrandsDocument = gql`
+    query FetchExtensionBrands {
+  fetchExtensionBrands {
+    brandId
+    name
+    matchingWords
+    description
+    industry
+    link
+    media
+  }
+}
+    `;
+
+/**
+ * __useFetchExtensionBrandsQuery__
+ *
+ * To run a query within a React component, call `useFetchExtensionBrandsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchExtensionBrandsQuery` 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 } = useFetchExtensionBrandsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchExtensionBrandsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchExtensionBrandsQuery, IFetchExtensionBrandsQueryVariables>) {
+        return Apollo.useQuery<IFetchExtensionBrandsQuery, IFetchExtensionBrandsQueryVariables>(FetchExtensionBrandsDocument, baseOptions);
+      }
+export function useFetchExtensionBrandsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchExtensionBrandsQuery, IFetchExtensionBrandsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchExtensionBrandsQuery, IFetchExtensionBrandsQueryVariables>(FetchExtensionBrandsDocument, baseOptions);
+        }
+export type FetchExtensionBrandsQueryHookResult = ReturnType<typeof useFetchExtensionBrandsQuery>;
+export type FetchExtensionBrandsLazyQueryHookResult = ReturnType<typeof useFetchExtensionBrandsLazyQuery>;
+export type FetchExtensionBrandsQueryResult = Apollo.QueryResult<IFetchExtensionBrandsQuery, IFetchExtensionBrandsQueryVariables>;
+export const FetchExtensionCategoriesDocument = gql`
+    query FetchExtensionCategories {
+  fetchExtensionCategories {
+    categoryId
+    name
+    matchingWords
+  }
+}
+    `;
+
+/**
+ * __useFetchExtensionCategoriesQuery__
+ *
+ * To run a query within a React component, call `useFetchExtensionCategoriesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchExtensionCategoriesQuery` 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 } = useFetchExtensionCategoriesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchExtensionCategoriesQuery(baseOptions?: Apollo.QueryHookOptions<IFetchExtensionCategoriesQuery, IFetchExtensionCategoriesQueryVariables>) {
+        return Apollo.useQuery<IFetchExtensionCategoriesQuery, IFetchExtensionCategoriesQueryVariables>(FetchExtensionCategoriesDocument, baseOptions);
+      }
+export function useFetchExtensionCategoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchExtensionCategoriesQuery, IFetchExtensionCategoriesQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchExtensionCategoriesQuery, IFetchExtensionCategoriesQueryVariables>(FetchExtensionCategoriesDocument, baseOptions);
+        }
+export type FetchExtensionCategoriesQueryHookResult = ReturnType<typeof useFetchExtensionCategoriesQuery>;
+export type FetchExtensionCategoriesLazyQueryHookResult = ReturnType<typeof useFetchExtensionCategoriesLazyQuery>;
+export type FetchExtensionCategoriesQueryResult = Apollo.QueryResult<IFetchExtensionCategoriesQuery, IFetchExtensionCategoriesQueryVariables>;
+export const FetchExtensionOpportunitiesV2Document = gql`
+    query FetchExtensionOpportunitiesV2($domain: String!, $brandId: String, $categoryId: String) {
+  fetchExtensionOpportunitiesV2(
+    domain: $domain
+    brandId: $brandId
+    categoryId: $categoryId
+  ) {
+    currentOpportunities {
+      opportunityId
+      brandId
+      categoryId
+      opportunityStatus
+      opportunityType
+      notificationType
+      name
+      brandName
+      brandDescription
+      brandMedia
+      brandUrl
+      brandIndustry
+      categoryName
+      description
+      ludoUrl
+      projectUrl
+      activeFrom
+      activeUntil
+      media
+      reportLink
+      shareLink
+    }
+    similarOpportunities {
+      opportunityId
+      brandId
+      categoryId
+      opportunityStatus
+      opportunityType
+      notificationType
+      name
+      brandName
+      brandDescription
+      brandMedia
+      brandUrl
+      brandIndustry
+      categoryName
+      description
+      ludoUrl
+      projectUrl
+      activeFrom
+      activeUntil
+      media
+      reportLink
+      shareLink
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchExtensionOpportunitiesV2Query__
+ *
+ * To run a query within a React component, call `useFetchExtensionOpportunitiesV2Query` and pass it any options that fit your needs.
+ * When your component renders, `useFetchExtensionOpportunitiesV2Query` 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 } = useFetchExtensionOpportunitiesV2Query({
+ *   variables: {
+ *      domain: // value for 'domain'
+ *      brandId: // value for 'brandId'
+ *      categoryId: // value for 'categoryId'
+ *   },
+ * });
+ */
+export function useFetchExtensionOpportunitiesV2Query(baseOptions: Apollo.QueryHookOptions<IFetchExtensionOpportunitiesV2Query, IFetchExtensionOpportunitiesV2QueryVariables>) {
+        return Apollo.useQuery<IFetchExtensionOpportunitiesV2Query, IFetchExtensionOpportunitiesV2QueryVariables>(FetchExtensionOpportunitiesV2Document, baseOptions);
+      }
+export function useFetchExtensionOpportunitiesV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchExtensionOpportunitiesV2Query, IFetchExtensionOpportunitiesV2QueryVariables>) {
+          return Apollo.useLazyQuery<IFetchExtensionOpportunitiesV2Query, IFetchExtensionOpportunitiesV2QueryVariables>(FetchExtensionOpportunitiesV2Document, baseOptions);
+        }
+export type FetchExtensionOpportunitiesV2QueryHookResult = ReturnType<typeof useFetchExtensionOpportunitiesV2Query>;
+export type FetchExtensionOpportunitiesV2LazyQueryHookResult = ReturnType<typeof useFetchExtensionOpportunitiesV2LazyQuery>;
+export type FetchExtensionOpportunitiesV2QueryResult = Apollo.QueryResult<IFetchExtensionOpportunitiesV2Query, IFetchExtensionOpportunitiesV2QueryVariables>;
+export const FetchNftDataDocument = gql`
+    query FetchNFTData($blockchain: String!, $contractAddress: String, $tokenId: String, $elrondId: String) {
+  fetchNFTData(
+    blockchain: $blockchain
+    contractAddress: $contractAddress
+    tokenId: $tokenId
+    elrondId: $elrondId
+  ) {
+    blockchain
+    contractAddress
+    tokenId
+    elrondId
+    collectionData {
+      collectionId
+      title
+      rank
+      createdAt
+      itemsNum
+      holdersNum
+      floorPrice
+    }
+    assetData {
+      assetId
+      rank
+    }
+    userRank
+  }
+}
+    `;
+
+/**
+ * __useFetchNftDataQuery__
+ *
+ * To run a query within a React component, call `useFetchNftDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchNftDataQuery` 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 } = useFetchNftDataQuery({
+ *   variables: {
+ *      blockchain: // value for 'blockchain'
+ *      contractAddress: // value for 'contractAddress'
+ *      tokenId: // value for 'tokenId'
+ *      elrondId: // value for 'elrondId'
+ *   },
+ * });
+ */
+export function useFetchNftDataQuery(baseOptions: Apollo.QueryHookOptions<IFetchNftDataQuery, IFetchNftDataQueryVariables>) {
+        return Apollo.useQuery<IFetchNftDataQuery, IFetchNftDataQueryVariables>(FetchNftDataDocument, baseOptions);
+      }
+export function useFetchNftDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchNftDataQuery, IFetchNftDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchNftDataQuery, IFetchNftDataQueryVariables>(FetchNftDataDocument, baseOptions);
+        }
+export type FetchNftDataQueryHookResult = ReturnType<typeof useFetchNftDataQuery>;
+export type FetchNftDataLazyQueryHookResult = ReturnType<typeof useFetchNftDataLazyQuery>;
+export type FetchNftDataQueryResult = Apollo.QueryResult<IFetchNftDataQuery, IFetchNftDataQueryVariables>;
+export const FetchNftRanksDocument = gql`
+    query FetchNFTRanks($nftKeys: [NFTKey!]!) {
+  fetchNFTRanks(nftKeys: $nftKeys) {
+    blockchain
+    address
+    tokenId
+    id
+    rank
+  }
+}
+    `;
+
+/**
+ * __useFetchNftRanksQuery__
+ *
+ * To run a query within a React component, call `useFetchNftRanksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchNftRanksQuery` 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 } = useFetchNftRanksQuery({
+ *   variables: {
+ *      nftKeys: // value for 'nftKeys'
+ *   },
+ * });
+ */
+export function useFetchNftRanksQuery(baseOptions: Apollo.QueryHookOptions<IFetchNftRanksQuery, IFetchNftRanksQueryVariables>) {
+        return Apollo.useQuery<IFetchNftRanksQuery, IFetchNftRanksQueryVariables>(FetchNftRanksDocument, baseOptions);
+      }
+export function useFetchNftRanksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchNftRanksQuery, IFetchNftRanksQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchNftRanksQuery, IFetchNftRanksQueryVariables>(FetchNftRanksDocument, baseOptions);
+        }
+export type FetchNftRanksQueryHookResult = ReturnType<typeof useFetchNftRanksQuery>;
+export type FetchNftRanksLazyQueryHookResult = ReturnType<typeof useFetchNftRanksLazyQuery>;
+export type FetchNftRanksQueryResult = Apollo.QueryResult<IFetchNftRanksQuery, IFetchNftRanksQueryVariables>;
+export const FetchWalletRanksDocument = gql`
+    query FetchWalletRanks($wallets: [String!]!) {
+  fetchWalletRanks(wallets: $wallets) {
+    wallet
+    rank
+  }
+}
+    `;
+
+/**
+ * __useFetchWalletRanksQuery__
+ *
+ * To run a query within a React component, call `useFetchWalletRanksQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchWalletRanksQuery` 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 } = useFetchWalletRanksQuery({
+ *   variables: {
+ *      wallets: // value for 'wallets'
+ *   },
+ * });
+ */
+export function useFetchWalletRanksQuery(baseOptions: Apollo.QueryHookOptions<IFetchWalletRanksQuery, IFetchWalletRanksQueryVariables>) {
+        return Apollo.useQuery<IFetchWalletRanksQuery, IFetchWalletRanksQueryVariables>(FetchWalletRanksDocument, baseOptions);
+      }
+export function useFetchWalletRanksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchWalletRanksQuery, IFetchWalletRanksQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchWalletRanksQuery, IFetchWalletRanksQueryVariables>(FetchWalletRanksDocument, baseOptions);
+        }
+export type FetchWalletRanksQueryHookResult = ReturnType<typeof useFetchWalletRanksQuery>;
+export type FetchWalletRanksLazyQueryHookResult = ReturnType<typeof useFetchWalletRanksLazyQuery>;
+export type FetchWalletRanksQueryResult = Apollo.QueryResult<IFetchWalletRanksQuery, IFetchWalletRanksQueryVariables>;