@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,1814 @@
+/* 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;
+  /** A file part in a multipart request */
+  Upload: any;
+};
+
+
+
+
+export type IActiveInvite = {
+  inviteCode?: Maybe<Scalars['String']>;
+  createdAt?: Maybe<Scalars['Long']>;
+};
+
+export type IAdminBrand = {
+  id: Scalars['String'];
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+  description: Scalars['String'];
+  industry?: Maybe<Scalars['String']>;
+  link?: Maybe<Scalars['String']>;
+  media?: Maybe<Scalars['String']>;
+  archived?: Maybe<Scalars['Boolean']>;
+  addedBy?: Maybe<Scalars['String']>;
+};
+
+export type IAdminCategory = {
+  id: Scalars['String'];
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+  archived?: Maybe<Scalars['Boolean']>;
+  addedBy?: Maybe<Scalars['String']>;
+};
+
+export type IAdminInvite = {
+  userId: Scalars['String'];
+  username?: Maybe<Scalars['String']>;
+  wallet?: Maybe<IWallet>;
+  activeInvites?: Maybe<Array<IActiveInvite>>;
+  referredUsers?: Maybe<Array<Scalars['String']>>;
+  userXpLevel?: Maybe<Scalars['Int']>;
+};
+
+export type IAdminOpportunity = {
+  opportunityId: Scalars['ID'];
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  brandName?: Maybe<Scalars['String']>;
+  industry?: Maybe<Scalars['String']>;
+  category?: Maybe<Scalars['String']>;
+  ludoUrl?: Maybe<Scalars['String']>;
+  projectUrl?: Maybe<Scalars['String']>;
+  pushNotificationsEnabled?: Maybe<Scalars['Boolean']>;
+  status?: Maybe<Scalars['String']>;
+  activeFrom?: Maybe<Scalars['Long']>;
+  activeUntil?: Maybe<Scalars['Long']>;
+  minXpLevel?: Maybe<Scalars['Int']>;
+  maxXpLevel?: Maybe<Scalars['Int']>;
+  minLudoRank?: Maybe<Scalars['Float']>;
+  maxLudoRank?: Maybe<Scalars['Float']>;
+  media?: Maybe<Scalars['String']>;
+  minWalletValue?: Maybe<Scalars['Float']>;
+  maxWalletValue?: Maybe<Scalars['Float']>;
+  clicks?: Maybe<Scalars['Int']>;
+  views?: Maybe<Scalars['Int']>;
+  addedBy?: Maybe<Scalars['String']>;
+};
+
+export type IAdminOpportunityInput = {
+  brandId: Scalars['String'];
+  categoryId: Scalars['String'];
+  status: Scalars['String'];
+  pushNotificationsEnabled: Scalars['Boolean'];
+  name: Scalars['String'];
+  description?: Maybe<Scalars['String']>;
+  ludoUrl?: Maybe<Scalars['String']>;
+  projectUrl?: Maybe<Scalars['String']>;
+  activeFrom?: Maybe<Scalars['Long']>;
+  activeUntil?: Maybe<Scalars['Long']>;
+  minXpLevel?: Maybe<Scalars['Int']>;
+  maxXpLevel?: Maybe<Scalars['Int']>;
+  minLudoRank?: Maybe<Scalars['Float']>;
+  maxLudoRank?: Maybe<Scalars['Float']>;
+  minWalletValue?: Maybe<Scalars['Float']>;
+  maxWalletValue?: Maybe<Scalars['Float']>;
+  blockchain?: Maybe<Scalars['String']>;
+  collection?: Maybe<Scalars['String']>;
+  media?: Maybe<Scalars['String']>;
+};
+
+export type IAdminPage = {
+  num?: Maybe<Scalars['Int']>;
+  lastNum?: Maybe<Scalars['Int']>;
+  size?: Maybe<Scalars['Int']>;
+  elements?: Maybe<Scalars['Long']>;
+  token?: Maybe<Scalars['String']>;
+};
+
+export type IAdminPageInput = {
+  num: Scalars['Int'];
+  size: Scalars['Int'];
+  token?: Maybe<Scalars['String']>;
+};
+
+export type IAdminReferral = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  mainWallet?: Maybe<IWallet>;
+  referredUsersNum?: Maybe<Scalars['Int']>;
+  referrals?: Maybe<Array<IReferredUsersInfo>>;
+};
+
+export type IAdminUser = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  wallets?: Maybe<Array<IWallet>>;
+  connectedBlockchains?: Maybe<Array<Scalars['String']>>;
+  isActive?: Maybe<Scalars['Boolean']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  topInterests?: Maybe<Array<Scalars['String']>>;
+  walletsValue?: Maybe<Scalars['Float']>;
+  xpLevel?: Maybe<Scalars['Int']>;
+  ludoRank?: Maybe<Scalars['Float']>;
+  inviterId?: Maybe<Scalars['String']>;
+};
+
+export type IAdminXp = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  mainWallet?: Maybe<IWallet>;
+  userXpLevel?: Maybe<Scalars['Int']>;
+  userXpPoints?: Maybe<Scalars['Int']>;
+  referredUsers?: Maybe<Array<Scalars['ID']>>;
+  referredUsersNum?: Maybe<Scalars['Int']>;
+  joinedOpportunityIds?: Maybe<Array<Scalars['String']>>;
+  connectedWalletsNum?: Maybe<Scalars['Int']>;
+  suggestedOpportunityIds?: Maybe<Array<Scalars['String']>>;
+};
+
+export type IBrandInput = {
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+  description: Scalars['String'];
+  industry?: Maybe<Scalars['String']>;
+  link?: Maybe<Scalars['String']>;
+  media?: Maybe<Scalars['String']>;
+};
+
+export type IBrandsFilterInput = {
+  nameTerm?: Maybe<Scalars['String']>;
+  descriptionTerm?: Maybe<Scalars['String']>;
+  industryTerm?: Maybe<Scalars['String']>;
+  linkTerm?: Maybe<Scalars['String']>;
+  matchingWordsTerm?: Maybe<Scalars['String']>;
+  addedByTerm?: Maybe<Scalars['String']>;
+};
+
+export type IBrandsPage = {
+  brands: Array<IAdminBrand>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IBrandsSortInput = {
+  sortByName?: Maybe<ISort>;
+  sortByIndustry?: Maybe<ISort>;
+  sortByAddedBy?: Maybe<ISort>;
+};
+
+export type ICategoriesFilterInput = {
+  nameTerm?: Maybe<Scalars['String']>;
+  matchingWordsTerm?: Maybe<Scalars['String']>;
+  addedByTerm?: Maybe<Scalars['String']>;
+};
+
+export type ICategoriesPage = {
+  categories: Array<IAdminCategory>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type ICategoriesSortInput = {
+  sortByName?: Maybe<ISort>;
+  sortByAddedBy?: Maybe<ISort>;
+};
+
+export type ICategoryInput = {
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+};
+
+export type IInvitesFilterInput = {
+  userIdTerm?: Maybe<Scalars['String']>;
+  usernameTerm?: Maybe<Scalars['String']>;
+  mainWalletTerm?: Maybe<Scalars['String']>;
+  userXpLevelTerm?: Maybe<Scalars['String']>;
+  activeInviteTerm?: Maybe<Scalars['String']>;
+  referredUserTerm?: Maybe<Scalars['String']>;
+};
+
+export type IInvitesPage = {
+  invites: Array<IAdminInvite>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IInvitesSortInput = {
+  sortByUsername?: Maybe<ISort>;
+  sortByXpLevel?: Maybe<ISort>;
+  sortByActiveInvites?: Maybe<ISort>;
+  sortByReferredUsers?: Maybe<ISort>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  removeInviteCode: Scalars['Boolean'];
+  addInviteCodes: Scalars['Boolean'];
+  updateOpportunityPushStatus: Scalars['Boolean'];
+  createBrand: Scalars['Boolean'];
+  updateBrand: Scalars['Boolean'];
+  updateBrandArchivedStatus: Scalars['Boolean'];
+  createCategory: Scalars['Boolean'];
+  updateCategory: Scalars['Boolean'];
+  updateCategoryArchivedStatus: Scalars['Boolean'];
+  createAdminOpportunity: Scalars['Boolean'];
+  updateOpportunity: Scalars['Boolean'];
+  updateProfileStatus: Scalars['Boolean'];
+  removeSuggestedOpportunity: Scalars['Boolean'];
+  addSuggestedOpportunity: Scalars['Boolean'];
+  changeXpPoints: Scalars['Boolean'];
+};
+
+
+export type IMutationRemoveInviteCodeArgs = {
+  inviteCode: Scalars['String'];
+};
+
+
+export type IMutationAddInviteCodesArgs = {
+  userId: Scalars['String'];
+  codesNum: Scalars['Int'];
+};
+
+
+export type IMutationUpdateOpportunityPushStatusArgs = {
+  opportunityId: Scalars['ID'];
+  isActive: Scalars['Boolean'];
+};
+
+
+export type IMutationCreateBrandArgs = {
+  brand: IBrandInput;
+  file?: Maybe<Scalars['Upload']>;
+};
+
+
+export type IMutationUpdateBrandArgs = {
+  id: Scalars['ID'];
+  input: IBrandInput;
+  file?: Maybe<Scalars['Upload']>;
+};
+
+
+export type IMutationUpdateBrandArchivedStatusArgs = {
+  id: Scalars['ID'];
+  isArchived: Scalars['Boolean'];
+};
+
+
+export type IMutationCreateCategoryArgs = {
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+};
+
+
+export type IMutationUpdateCategoryArgs = {
+  id: Scalars['ID'];
+  input: ICategoryInput;
+};
+
+
+export type IMutationUpdateCategoryArchivedStatusArgs = {
+  id: Scalars['ID'];
+  isArchived: Scalars['Boolean'];
+};
+
+
+export type IMutationCreateAdminOpportunityArgs = {
+  input: IAdminOpportunityInput;
+  file?: Maybe<Scalars['Upload']>;
+};
+
+
+export type IMutationUpdateOpportunityArgs = {
+  id: Scalars['ID'];
+  input: IAdminOpportunityInput;
+  file?: Maybe<Scalars['Upload']>;
+};
+
+
+export type IMutationUpdateProfileStatusArgs = {
+  userId: Scalars['ID'];
+  isActive: Scalars['Boolean'];
+};
+
+
+export type IMutationRemoveSuggestedOpportunityArgs = {
+  userId: Scalars['ID'];
+  opportunityId: Scalars['String'];
+};
+
+
+export type IMutationAddSuggestedOpportunityArgs = {
+  userId: Scalars['ID'];
+  opportunityId: Scalars['String'];
+};
+
+
+export type IMutationChangeXpPointsArgs = {
+  userId: Scalars['ID'];
+  pointsDiff: Scalars['Int'];
+};
+
+export type IOpportunitiesFilterInput = {
+  opportunityIdTerm?: Maybe<Scalars['String']>;
+  industryTerm?: Maybe<Scalars['String']>;
+  categoryTerm?: Maybe<Scalars['String']>;
+  opportunityLudoUrlTerm?: Maybe<Scalars['String']>;
+  opportunityProjectUrlTerm?: Maybe<Scalars['String']>;
+  arePushNotificationsEnabled?: Maybe<Scalars['Boolean']>;
+  opportunityStatusTerm?: Maybe<Scalars['String']>;
+  activeFromTimestamp?: Maybe<Scalars['Long']>;
+  activeUntilTimestamp?: Maybe<Scalars['Long']>;
+  minXpLevel?: Maybe<Scalars['Int']>;
+  maxXpLevel?: Maybe<Scalars['Int']>;
+  minLudoRank?: Maybe<Scalars['Float']>;
+  maxLudoRank?: Maybe<Scalars['Float']>;
+  minWalletValue?: Maybe<Scalars['Float']>;
+  maxWalletValue?: Maybe<Scalars['Float']>;
+  clicks?: Maybe<Scalars['Int']>;
+  views?: Maybe<Scalars['Int']>;
+  addedByTerm?: Maybe<Scalars['String']>;
+};
+
+export type IOpportunitiesPage = {
+  opportunities: Array<IAdminOpportunity>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IOpportunitiesSortInput = {
+  sortByOpportunityName?: Maybe<ISort>;
+  sortByBrandName?: Maybe<ISort>;
+  sortByCategory?: Maybe<ISort>;
+  sortByOpportunityStatus?: Maybe<ISort>;
+  sortByActiveFrom?: Maybe<ISort>;
+  sortByActiveUntil?: Maybe<ISort>;
+  sortByMinXpLevel?: Maybe<ISort>;
+  sortByMaxXpLevel?: Maybe<ISort>;
+  sortByAddedBy?: Maybe<ISort>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchAdminInvitesPage: IInvitesPage;
+  fetchAdminOpportunitiesPage: IOpportunitiesPage;
+  fetchAdminCategories: Array<IAdminCategory>;
+  fetchAdminCategoriesPage: ICategoriesPage;
+  fetchAdminBrands: Array<IAdminBrand>;
+  fetchAdminBrandsPage: IBrandsPage;
+  fetchBlockchains: Array<Scalars['String']>;
+  fetchAdminReferralsPage: IReferralsPage;
+  fetchAdminUsersPage: IUsersPage;
+  fetchAdminXpPage: IXpPage;
+};
+
+
+export type IQueryFetchAdminInvitesPageArgs = {
+  filter: IInvitesFilterInput;
+  sort: IInvitesSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminOpportunitiesPageArgs = {
+  filter: IOpportunitiesFilterInput;
+  sort: IOpportunitiesSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminCategoriesPageArgs = {
+  filter: ICategoriesFilterInput;
+  sort: ICategoriesSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminBrandsPageArgs = {
+  filter: IBrandsFilterInput;
+  sort: IBrandsSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminReferralsPageArgs = {
+  filter: IReferralsFilterInput;
+  sort: IReferralsSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminUsersPageArgs = {
+  filter: IUsersFilterInput;
+  sort: IUsersSortInput;
+  page: IAdminPageInput;
+};
+
+
+export type IQueryFetchAdminXpPageArgs = {
+  filter: IXpFilterInput;
+  sort: IXpSortInput;
+  page: IAdminPageInput;
+};
+
+export type IReferralsFilterInput = {
+  userIdTerm?: Maybe<Scalars['String']>;
+  usernameTerm?: Maybe<Scalars['String']>;
+  mainWalletTerm?: Maybe<Scalars['String']>;
+  referredUsersNumTerm?: Maybe<Scalars['String']>;
+  userRefUrlTerm?: Maybe<Scalars['String']>;
+  opportunityUrlTerm?: Maybe<Scalars['String']>;
+};
+
+export type IReferralsPage = {
+  adminReferrals: Array<IAdminReferral>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IReferralsSortInput = {
+  sortByUsername?: Maybe<ISort>;
+  sortByReferredUsersNum?: Maybe<ISort>;
+};
+
+export type IReferredUsersInfo = {
+  userRefUrl: Scalars['String'];
+  opportunityUrl: Scalars['String'];
+  referredUsersPerUrlNum: Scalars['Int'];
+};
+
+export type ISort = {
+  enabled: Scalars['Boolean'];
+  direction?: Maybe<ISortDirection>;
+};
+
+/** front-end asked for lower case values */
+export enum ISortDirection {
+  Asc = 'asc',
+  Desc = 'desc'
+}
+
+
+export type IUsersFilterInput = {
+  userIdTerm?: Maybe<Scalars['String']>;
+  usernameTerm?: Maybe<Scalars['String']>;
+  walletsTerm?: Maybe<Scalars['String']>;
+  connectedBlockchainsTerm?: Maybe<Scalars['String']>;
+  isActiveAccount?: Maybe<Scalars['Boolean']>;
+  createdDateTimestamp?: Maybe<Scalars['Long']>;
+  interestTerm?: Maybe<Scalars['String']>;
+  walletsValue?: Maybe<Scalars['Float']>;
+  xpLevel?: Maybe<Scalars['Int']>;
+  ludoRank?: Maybe<Scalars['Float']>;
+  invitedByTerm?: Maybe<Scalars['String']>;
+};
+
+export type IUsersPage = {
+  users: Array<IAdminUser>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IUsersSortInput = {
+  sortByUsername?: Maybe<ISort>;
+  sortByAccountStatus?: Maybe<ISort>;
+  sortByCreatedDate?: Maybe<ISort>;
+  sortByWalletsValue?: Maybe<ISort>;
+  sortByXpLevel?: Maybe<ISort>;
+  sortByLudoRank?: Maybe<ISort>;
+};
+
+export type IWallet = {
+  address: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+  isMain?: Maybe<Scalars['Boolean']>;
+};
+
+export type IXpFilterInput = {
+  userIdTerm?: Maybe<Scalars['String']>;
+  usernameTerm?: Maybe<Scalars['String']>;
+  mainWalletTerm?: Maybe<Scalars['String']>;
+  userXpLevelTerm?: Maybe<Scalars['String']>;
+  userXpPointsTerm?: Maybe<Scalars['String']>;
+  invitedUserTerm?: Maybe<Scalars['String']>;
+  referredUsersNumTerm?: Maybe<Scalars['String']>;
+  joinedOpportunityTerm?: Maybe<Scalars['String']>;
+  connectedWalletsNumTerm?: Maybe<Scalars['String']>;
+  suggestedOpportunityTerm?: Maybe<Scalars['String']>;
+};
+
+export type IXpPage = {
+  xps: Array<IAdminXp>;
+  nextPage?: Maybe<IAdminPage>;
+};
+
+export type IXpSortInput = {
+  sortByUsername?: Maybe<ISort>;
+  sortByXpLevel?: Maybe<ISort>;
+  sortByXpPoints?: Maybe<ISort>;
+  sortByInvitedUsers?: Maybe<ISort>;
+  sortByReferredUsersNum?: Maybe<ISort>;
+  sortByJoinedOpportunities?: Maybe<ISort>;
+  sortByConnectedWalletsNum?: Maybe<ISort>;
+  sortBySuggestedOpportunities?: Maybe<ISort>;
+};
+
+
+
+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 = {
+  ActiveInvite: ResolverTypeWrapper<IActiveInvite>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  AdminBrand: ResolverTypeWrapper<IAdminBrand>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  AdminCategory: ResolverTypeWrapper<IAdminCategory>;
+  AdminInvite: ResolverTypeWrapper<IAdminInvite>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  AdminOpportunity: ResolverTypeWrapper<IAdminOpportunity>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  AdminOpportunityInput: IAdminOpportunityInput;
+  AdminPage: ResolverTypeWrapper<IAdminPage>;
+  AdminPageInput: IAdminPageInput;
+  AdminReferral: ResolverTypeWrapper<IAdminReferral>;
+  AdminUser: ResolverTypeWrapper<IAdminUser>;
+  AdminXp: ResolverTypeWrapper<IAdminXp>;
+  BrandInput: IBrandInput;
+  BrandsFilterInput: IBrandsFilterInput;
+  BrandsPage: ResolverTypeWrapper<IBrandsPage>;
+  BrandsSortInput: IBrandsSortInput;
+  CategoriesFilterInput: ICategoriesFilterInput;
+  CategoriesPage: ResolverTypeWrapper<ICategoriesPage>;
+  CategoriesSortInput: ICategoriesSortInput;
+  CategoryInput: ICategoryInput;
+  InvitesFilterInput: IInvitesFilterInput;
+  InvitesPage: ResolverTypeWrapper<IInvitesPage>;
+  InvitesSortInput: IInvitesSortInput;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  OpportunitiesFilterInput: IOpportunitiesFilterInput;
+  OpportunitiesPage: ResolverTypeWrapper<IOpportunitiesPage>;
+  OpportunitiesSortInput: IOpportunitiesSortInput;
+  Query: ResolverTypeWrapper<{}>;
+  ReferralsFilterInput: IReferralsFilterInput;
+  ReferralsPage: ResolverTypeWrapper<IReferralsPage>;
+  ReferralsSortInput: IReferralsSortInput;
+  ReferredUsersInfo: ResolverTypeWrapper<IReferredUsersInfo>;
+  Sort: ISort;
+  SortDirection: ISortDirection;
+  Upload: ResolverTypeWrapper<Scalars['Upload']>;
+  UsersFilterInput: IUsersFilterInput;
+  UsersPage: ResolverTypeWrapper<IUsersPage>;
+  UsersSortInput: IUsersSortInput;
+  Wallet: ResolverTypeWrapper<IWallet>;
+  XpFilterInput: IXpFilterInput;
+  XpPage: ResolverTypeWrapper<IXpPage>;
+  XpSortInput: IXpSortInput;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  ActiveInvite: IActiveInvite;
+  String: Scalars['String'];
+  AdminBrand: IAdminBrand;
+  Boolean: Scalars['Boolean'];
+  AdminCategory: IAdminCategory;
+  AdminInvite: IAdminInvite;
+  Int: Scalars['Int'];
+  AdminOpportunity: IAdminOpportunity;
+  ID: Scalars['ID'];
+  Float: Scalars['Float'];
+  AdminOpportunityInput: IAdminOpportunityInput;
+  AdminPage: IAdminPage;
+  AdminPageInput: IAdminPageInput;
+  AdminReferral: IAdminReferral;
+  AdminUser: IAdminUser;
+  AdminXp: IAdminXp;
+  BrandInput: IBrandInput;
+  BrandsFilterInput: IBrandsFilterInput;
+  BrandsPage: IBrandsPage;
+  BrandsSortInput: IBrandsSortInput;
+  CategoriesFilterInput: ICategoriesFilterInput;
+  CategoriesPage: ICategoriesPage;
+  CategoriesSortInput: ICategoriesSortInput;
+  CategoryInput: ICategoryInput;
+  InvitesFilterInput: IInvitesFilterInput;
+  InvitesPage: IInvitesPage;
+  InvitesSortInput: IInvitesSortInput;
+  Long: Scalars['Long'];
+  Mutation: {};
+  OpportunitiesFilterInput: IOpportunitiesFilterInput;
+  OpportunitiesPage: IOpportunitiesPage;
+  OpportunitiesSortInput: IOpportunitiesSortInput;
+  Query: {};
+  ReferralsFilterInput: IReferralsFilterInput;
+  ReferralsPage: IReferralsPage;
+  ReferralsSortInput: IReferralsSortInput;
+  ReferredUsersInfo: IReferredUsersInfo;
+  Sort: ISort;
+  Upload: Scalars['Upload'];
+  UsersFilterInput: IUsersFilterInput;
+  UsersPage: IUsersPage;
+  UsersSortInput: IUsersSortInput;
+  Wallet: IWallet;
+  XpFilterInput: IXpFilterInput;
+  XpPage: IXpPage;
+  XpSortInput: IXpSortInput;
+};
+
+export type IMinDirectiveArgs = {
+  value?: Maybe<Scalars['Int']>;
+  message?: Maybe<Scalars['String']>;
+};
+
+export type IMinDirectiveResolver<Result, Parent, ContextType = any, Args = IMinDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IRangeDirectiveArgs = {
+  min?: Maybe<Scalars['Int']>;
+  max?: Maybe<Scalars['Int']>;
+  message?: Maybe<Scalars['String']>;
+};
+
+export type IRangeDirectiveResolver<Result, Parent, ContextType = any, Args = IRangeDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IActiveInviteResolvers<ContextType = any, ParentType extends IResolversParentTypes['ActiveInvite'] = IResolversParentTypes['ActiveInvite']> = {
+  inviteCode?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminBrandResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminBrand'] = IResolversParentTypes['AdminBrand']> = {
+  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  matchingWords?: Resolver<Array<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<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>;
+  archived?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  addedBy?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminCategoryResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminCategory'] = IResolversParentTypes['AdminCategory']> = {
+  id?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  matchingWords?: Resolver<Array<IResolversTypes['String']>, ParentType, ContextType>;
+  archived?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  addedBy?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminInviteResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminInvite'] = IResolversParentTypes['AdminInvite']> = {
+  userId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  wallet?: Resolver<Maybe<IResolversTypes['Wallet']>, ParentType, ContextType>;
+  activeInvites?: Resolver<Maybe<Array<IResolversTypes['ActiveInvite']>>, ParentType, ContextType>;
+  referredUsers?: Resolver<Maybe<Array<IResolversTypes['String']>>, ParentType, ContextType>;
+  userXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminOpportunityResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminOpportunity'] = IResolversParentTypes['AdminOpportunity']> = {
+  opportunityId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  brandName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  industry?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  ludoUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  projectUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  pushNotificationsEnabled?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  status?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  activeFrom?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  activeUntil?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  minXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  maxXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  minLudoRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  maxLudoRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  media?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  minWalletValue?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  maxWalletValue?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  clicks?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  addedBy?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminPage'] = IResolversParentTypes['AdminPage']> = {
+  num?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  lastNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  size?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  elements?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  token?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminReferralResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminReferral'] = IResolversParentTypes['AdminReferral']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mainWallet?: Resolver<Maybe<IResolversTypes['Wallet']>, ParentType, ContextType>;
+  referredUsersNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  referrals?: Resolver<Maybe<Array<IResolversTypes['ReferredUsersInfo']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminUserResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminUser'] = IResolversParentTypes['AdminUser']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  wallets?: Resolver<Maybe<Array<IResolversTypes['Wallet']>>, ParentType, ContextType>;
+  connectedBlockchains?: Resolver<Maybe<Array<IResolversTypes['String']>>, ParentType, ContextType>;
+  isActive?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  topInterests?: Resolver<Maybe<Array<IResolversTypes['String']>>, ParentType, ContextType>;
+  walletsValue?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  xpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  ludoRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  inviterId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAdminXpResolvers<ContextType = any, ParentType extends IResolversParentTypes['AdminXp'] = IResolversParentTypes['AdminXp']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mainWallet?: Resolver<Maybe<IResolversTypes['Wallet']>, ParentType, ContextType>;
+  userXpLevel?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  userXpPoints?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  referredUsers?: Resolver<Maybe<Array<IResolversTypes['ID']>>, ParentType, ContextType>;
+  referredUsersNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  joinedOpportunityIds?: Resolver<Maybe<Array<IResolversTypes['String']>>, ParentType, ContextType>;
+  connectedWalletsNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  suggestedOpportunityIds?: Resolver<Maybe<Array<IResolversTypes['String']>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IBrandsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['BrandsPage'] = IResolversParentTypes['BrandsPage']> = {
+  brands?: Resolver<Array<IResolversTypes['AdminBrand']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICategoriesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['CategoriesPage'] = IResolversParentTypes['CategoriesPage']> = {
+  categories?: Resolver<Array<IResolversTypes['AdminCategory']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IInvitesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['InvitesPage'] = IResolversParentTypes['InvitesPage']> = {
+  invites?: Resolver<Array<IResolversTypes['AdminInvite']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, 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>;
+  removeInviteCode?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationRemoveInviteCodeArgs, 'inviteCode'>>;
+  addInviteCodes?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddInviteCodesArgs, 'userId' | 'codesNum'>>;
+  updateOpportunityPushStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateOpportunityPushStatusArgs, 'opportunityId' | 'isActive'>>;
+  createBrand?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateBrandArgs, 'brand'>>;
+  updateBrand?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateBrandArgs, 'id' | 'input'>>;
+  updateBrandArchivedStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateBrandArchivedStatusArgs, 'id' | 'isArchived'>>;
+  createCategory?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateCategoryArgs, 'name' | 'matchingWords'>>;
+  updateCategory?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateCategoryArgs, 'id' | 'input'>>;
+  updateCategoryArchivedStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateCategoryArchivedStatusArgs, 'id' | 'isArchived'>>;
+  createAdminOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateAdminOpportunityArgs, 'input'>>;
+  updateOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateOpportunityArgs, 'id' | 'input'>>;
+  updateProfileStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateProfileStatusArgs, 'userId' | 'isActive'>>;
+  removeSuggestedOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationRemoveSuggestedOpportunityArgs, 'userId' | 'opportunityId'>>;
+  addSuggestedOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddSuggestedOpportunityArgs, 'userId' | 'opportunityId'>>;
+  changeXpPoints?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationChangeXpPointsArgs, 'userId' | 'pointsDiff'>>;
+};
+
+export type IOpportunitiesPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['OpportunitiesPage'] = IResolversParentTypes['OpportunitiesPage']> = {
+  opportunities?: Resolver<Array<IResolversTypes['AdminOpportunity']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchAdminInvitesPage?: Resolver<IResolversTypes['InvitesPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminInvitesPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchAdminOpportunitiesPage?: Resolver<IResolversTypes['OpportunitiesPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminOpportunitiesPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchAdminCategories?: Resolver<Array<IResolversTypes['AdminCategory']>, ParentType, ContextType>;
+  fetchAdminCategoriesPage?: Resolver<IResolversTypes['CategoriesPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminCategoriesPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchAdminBrands?: Resolver<Array<IResolversTypes['AdminBrand']>, ParentType, ContextType>;
+  fetchAdminBrandsPage?: Resolver<IResolversTypes['BrandsPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminBrandsPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchBlockchains?: Resolver<Array<IResolversTypes['String']>, ParentType, ContextType>;
+  fetchAdminReferralsPage?: Resolver<IResolversTypes['ReferralsPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminReferralsPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchAdminUsersPage?: Resolver<IResolversTypes['UsersPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminUsersPageArgs, 'filter' | 'sort' | 'page'>>;
+  fetchAdminXpPage?: Resolver<IResolversTypes['XpPage'], ParentType, ContextType, RequireFields<IQueryFetchAdminXpPageArgs, 'filter' | 'sort' | 'page'>>;
+};
+
+export type IReferralsPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['ReferralsPage'] = IResolversParentTypes['ReferralsPage']> = {
+  adminReferrals?: Resolver<Array<IResolversTypes['AdminReferral']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IReferredUsersInfoResolvers<ContextType = any, ParentType extends IResolversParentTypes['ReferredUsersInfo'] = IResolversParentTypes['ReferredUsersInfo']> = {
+  userRefUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  opportunityUrl?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  referredUsersPerUrlNum?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface IUploadScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Upload'], any> {
+  name: 'Upload';
+}
+
+export type IUsersPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['UsersPage'] = IResolversParentTypes['UsersPage']> = {
+  users?: Resolver<Array<IResolversTypes['AdminUser']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IWalletResolvers<ContextType = any, ParentType extends IResolversParentTypes['Wallet'] = IResolversParentTypes['Wallet']> = {
+  address?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  blockchain?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  chainId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  isMain?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IXpPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['XpPage'] = IResolversParentTypes['XpPage']> = {
+  xps?: Resolver<Array<IResolversTypes['AdminXp']>, ParentType, ContextType>;
+  nextPage?: Resolver<Maybe<IResolversTypes['AdminPage']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  ActiveInvite?: IActiveInviteResolvers<ContextType>;
+  AdminBrand?: IAdminBrandResolvers<ContextType>;
+  AdminCategory?: IAdminCategoryResolvers<ContextType>;
+  AdminInvite?: IAdminInviteResolvers<ContextType>;
+  AdminOpportunity?: IAdminOpportunityResolvers<ContextType>;
+  AdminPage?: IAdminPageResolvers<ContextType>;
+  AdminReferral?: IAdminReferralResolvers<ContextType>;
+  AdminUser?: IAdminUserResolvers<ContextType>;
+  AdminXp?: IAdminXpResolvers<ContextType>;
+  BrandsPage?: IBrandsPageResolvers<ContextType>;
+  CategoriesPage?: ICategoriesPageResolvers<ContextType>;
+  InvitesPage?: IInvitesPageResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  OpportunitiesPage?: IOpportunitiesPageResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  ReferralsPage?: IReferralsPageResolvers<ContextType>;
+  ReferredUsersInfo?: IReferredUsersInfoResolvers<ContextType>;
+  Upload?: GraphQLScalarType;
+  UsersPage?: IUsersPageResolvers<ContextType>;
+  Wallet?: IWalletResolvers<ContextType>;
+  XpPage?: IXpPageResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  Min?: IMinDirectiveResolver<any, any, ContextType>;
+  Range?: IRangeDirectiveResolver<any, any, ContextType>;
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IChangeXpPointsMutationVariables = Exact<{
+  userId: Scalars['ID'];
+  pointsDiff: Scalars['Int'];
+}>;
+
+
+export type IChangeXpPointsMutation = Pick<IMutation, 'changeXpPoints'>;
+
+export type ICreateCategoryMutationVariables = Exact<{
+  name: Scalars['String'];
+  matchingWords: Array<Scalars['String']>;
+}>;
+
+
+export type ICreateCategoryMutation = Pick<IMutation, 'createCategory'>;
+
+export type ICreateBrandMutationVariables = Exact<{
+  brand: IBrandInput;
+  file?: Maybe<Scalars['Upload']>;
+}>;
+
+
+export type ICreateBrandMutation = Pick<IMutation, 'createBrand'>;
+
+export type ICreateAdminOpportunityMutationVariables = Exact<{
+  file?: Maybe<Scalars['Upload']>;
+  input: IAdminOpportunityInput;
+}>;
+
+
+export type ICreateAdminOpportunityMutation = Pick<IMutation, 'createAdminOpportunity'>;
+
+export type IAddInviteCodesMutationVariables = Exact<{
+  userId: Scalars['String'];
+  codesNum: Scalars['Int'];
+}>;
+
+
+export type IAddInviteCodesMutation = Pick<IMutation, 'addInviteCodes'>;
+
+export type IRemoveInviteCodeMutationVariables = Exact<{
+  inviteCode: Scalars['String'];
+}>;
+
+
+export type IRemoveInviteCodeMutation = Pick<IMutation, 'removeInviteCode'>;
+
+export type IUpdateProfileStatusMutationVariables = Exact<{
+  userId: Scalars['ID'];
+  isActive: Scalars['Boolean'];
+}>;
+
+
+export type IUpdateProfileStatusMutation = Pick<IMutation, 'updateProfileStatus'>;
+
+export type IFetchAdminBrandsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchAdminBrandsQuery = { fetchAdminBrands: Array<Pick<IAdminBrand, 'id' | 'name'>> };
+
+export type IFetchAdminBrandsPageQueryVariables = Exact<{
+  filter: IBrandsFilterInput;
+  sort: IBrandsSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminBrandsPageQuery = { fetchAdminBrandsPage: { brands: Array<Pick<IAdminBrand, 'description' | 'id' | 'industry' | 'link' | 'matchingWords' | 'media' | 'name' | 'archived' | 'addedBy'>>, nextPage?: Maybe<Pick<IAdminPage, 'num' | 'lastNum' | 'size' | 'elements'>> } };
+
+export type IFetchAdminCategoriesQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchAdminCategoriesQuery = { fetchAdminCategories: Array<Pick<IAdminCategory, 'id' | 'name'>> };
+
+export type IFetchAdminCategoriesPageQueryVariables = Exact<{
+  filter: ICategoriesFilterInput;
+  sort: ICategoriesSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminCategoriesPageQuery = { fetchAdminCategoriesPage: { categories: Array<Pick<IAdminCategory, 'id' | 'name' | 'matchingWords' | 'archived' | 'addedBy'>>, nextPage?: Maybe<Pick<IAdminPage, 'num' | 'lastNum' | 'size' | 'elements'>> } };
+
+export type IFetchAdminInvitesPageQueryVariables = Exact<{
+  filter: IInvitesFilterInput;
+  sort: IInvitesSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminInvitesPageQuery = { fetchAdminInvitesPage: { invites: Array<(
+      Pick<IAdminInvite, 'userId' | 'username' | 'referredUsers' | 'userXpLevel'>
+      & { wallet?: Maybe<Pick<IWallet, 'address' | 'blockchain' | 'chainId'>>, activeInvites?: Maybe<Array<Pick<IActiveInvite, 'inviteCode' | 'createdAt'>>> }
+    )>, nextPage?: Maybe<Pick<IAdminPage, 'num' | 'lastNum' | 'size' | 'elements' | 'token'>> } };
+
+export type IFetchAdminOpportunitiesPageQueryVariables = Exact<{
+  filter: IOpportunitiesFilterInput;
+  sort: IOpportunitiesSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminOpportunitiesPageQuery = { fetchAdminOpportunitiesPage: { opportunities: Array<Pick<IAdminOpportunity, 'opportunityId' | 'name' | 'brandName' | 'industry' | 'category' | 'ludoUrl' | 'projectUrl' | 'pushNotificationsEnabled' | 'status' | 'media' | 'description' | 'activeFrom' | 'activeUntil' | 'minXpLevel' | 'maxXpLevel' | 'minLudoRank' | 'maxLudoRank' | 'minWalletValue' | 'maxWalletValue' | 'clicks' | 'views' | 'addedBy'>>, nextPage?: Maybe<Pick<IAdminPage, 'elements' | 'lastNum' | 'num' | 'size' | 'token'>> } };
+
+export type IFetchAdminReferralsPageQueryVariables = Exact<{
+  filter: IReferralsFilterInput;
+  sort: IReferralsSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminReferralsPageQuery = { fetchAdminReferralsPage: { adminReferrals: Array<(
+      Pick<IAdminReferral, 'userId' | 'username' | 'referredUsersNum'>
+      & { mainWallet?: Maybe<Pick<IWallet, 'address' | 'blockchain' | 'chainId'>>, referrals?: Maybe<Array<Pick<IReferredUsersInfo, 'userRefUrl' | 'opportunityUrl' | 'referredUsersPerUrlNum'>>> }
+    )>, nextPage?: Maybe<Pick<IAdminPage, 'elements' | 'lastNum' | 'num' | 'size' | 'token'>> } };
+
+export type IFetchAdminUsersPageQueryVariables = Exact<{
+  filter: IUsersFilterInput;
+  sort: IUsersSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminUsersPageQuery = { fetchAdminUsersPage: { users: Array<(
+      Pick<IAdminUser, 'userId' | 'username' | 'connectedBlockchains' | 'isActive' | 'createdAt' | 'topInterests' | 'walletsValue' | 'xpLevel' | 'ludoRank' | 'inviterId'>
+      & { wallets?: Maybe<Array<Pick<IWallet, 'address' | 'blockchain' | 'chainId'>>> }
+    )>, nextPage?: Maybe<Pick<IAdminPage, 'num' | 'lastNum' | 'size' | 'elements' | 'token'>> } };
+
+export type IFetchAdminXpPageQueryVariables = Exact<{
+  filter: IXpFilterInput;
+  sort: IXpSortInput;
+  page: IAdminPageInput;
+}>;
+
+
+export type IFetchAdminXpPageQuery = { fetchAdminXpPage: { xps: Array<(
+      Pick<IAdminXp, 'userId' | 'username' | 'userXpLevel' | 'userXpPoints' | 'referredUsers' | 'referredUsersNum' | 'joinedOpportunityIds' | 'connectedWalletsNum' | 'suggestedOpportunityIds'>
+      & { mainWallet?: Maybe<Pick<IWallet, 'address' | 'blockchain' | 'chainId'>> }
+    )>, nextPage?: Maybe<Pick<IAdminPage, 'elements' | 'lastNum' | 'num' | 'size' | 'token'>> } };
+
+export type IFetchBlockchainsQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchBlockchainsQuery = Pick<IQuery, 'fetchBlockchains'>;
+
+
+export const ChangeXpPointsDocument = gql`
+    mutation ChangeXpPoints($userId: ID!, $pointsDiff: Int!) {
+  changeXpPoints(userId: $userId, pointsDiff: $pointsDiff)
+}
+    `;
+export type IChangeXpPointsMutationFn = Apollo.MutationFunction<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>;
+
+/**
+ * __useChangeXpPointsMutation__
+ *
+ * To run a mutation, you first call `useChangeXpPointsMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useChangeXpPointsMutation` 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 [changeXpPointsMutation, { data, loading, error }] = useChangeXpPointsMutation({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      pointsDiff: // value for 'pointsDiff'
+ *   },
+ * });
+ */
+export function useChangeXpPointsMutation(baseOptions?: Apollo.MutationHookOptions<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>) {
+        return Apollo.useMutation<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>(ChangeXpPointsDocument, baseOptions);
+      }
+export type ChangeXpPointsMutationHookResult = ReturnType<typeof useChangeXpPointsMutation>;
+export type ChangeXpPointsMutationResult = Apollo.MutationResult<IChangeXpPointsMutation>;
+export type ChangeXpPointsMutationOptions = Apollo.BaseMutationOptions<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>;
+export const CreateCategoryDocument = gql`
+    mutation CreateCategory($name: String!, $matchingWords: [String!]!) {
+  createCategory(name: $name, matchingWords: $matchingWords)
+}
+    `;
+export type ICreateCategoryMutationFn = Apollo.MutationFunction<ICreateCategoryMutation, ICreateCategoryMutationVariables>;
+
+/**
+ * __useCreateCategoryMutation__
+ *
+ * To run a mutation, you first call `useCreateCategoryMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateCategoryMutation` 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 [createCategoryMutation, { data, loading, error }] = useCreateCategoryMutation({
+ *   variables: {
+ *      name: // value for 'name'
+ *      matchingWords: // value for 'matchingWords'
+ *   },
+ * });
+ */
+export function useCreateCategoryMutation(baseOptions?: Apollo.MutationHookOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>) {
+        return Apollo.useMutation<ICreateCategoryMutation, ICreateCategoryMutationVariables>(CreateCategoryDocument, baseOptions);
+      }
+export type CreateCategoryMutationHookResult = ReturnType<typeof useCreateCategoryMutation>;
+export type CreateCategoryMutationResult = Apollo.MutationResult<ICreateCategoryMutation>;
+export type CreateCategoryMutationOptions = Apollo.BaseMutationOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>;
+export const CreateBrandDocument = gql`
+    mutation CreateBrand($brand: BrandInput!, $file: Upload) {
+  createBrand(brand: $brand, file: $file)
+}
+    `;
+export type ICreateBrandMutationFn = Apollo.MutationFunction<ICreateBrandMutation, ICreateBrandMutationVariables>;
+
+/**
+ * __useCreateBrandMutation__
+ *
+ * To run a mutation, you first call `useCreateBrandMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateBrandMutation` 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 [createBrandMutation, { data, loading, error }] = useCreateBrandMutation({
+ *   variables: {
+ *      brand: // value for 'brand'
+ *      file: // value for 'file'
+ *   },
+ * });
+ */
+export function useCreateBrandMutation(baseOptions?: Apollo.MutationHookOptions<ICreateBrandMutation, ICreateBrandMutationVariables>) {
+        return Apollo.useMutation<ICreateBrandMutation, ICreateBrandMutationVariables>(CreateBrandDocument, baseOptions);
+      }
+export type CreateBrandMutationHookResult = ReturnType<typeof useCreateBrandMutation>;
+export type CreateBrandMutationResult = Apollo.MutationResult<ICreateBrandMutation>;
+export type CreateBrandMutationOptions = Apollo.BaseMutationOptions<ICreateBrandMutation, ICreateBrandMutationVariables>;
+export const CreateAdminOpportunityDocument = gql`
+    mutation createAdminOpportunity($file: Upload, $input: AdminOpportunityInput!) {
+  createAdminOpportunity(file: $file, input: $input)
+}
+    `;
+export type ICreateAdminOpportunityMutationFn = Apollo.MutationFunction<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>;
+
+/**
+ * __useCreateAdminOpportunityMutation__
+ *
+ * To run a mutation, you first call `useCreateAdminOpportunityMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateAdminOpportunityMutation` 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 [createAdminOpportunityMutation, { data, loading, error }] = useCreateAdminOpportunityMutation({
+ *   variables: {
+ *      file: // value for 'file'
+ *      input: // value for 'input'
+ *   },
+ * });
+ */
+export function useCreateAdminOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>) {
+        return Apollo.useMutation<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>(CreateAdminOpportunityDocument, baseOptions);
+      }
+export type CreateAdminOpportunityMutationHookResult = ReturnType<typeof useCreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationResult = Apollo.MutationResult<ICreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationOptions = Apollo.BaseMutationOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>;
+export const AddInviteCodesDocument = gql`
+    mutation AddInviteCodes($userId: String!, $codesNum: Int!) {
+  addInviteCodes(userId: $userId, codesNum: $codesNum)
+}
+    `;
+export type IAddInviteCodesMutationFn = Apollo.MutationFunction<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>;
+
+/**
+ * __useAddInviteCodesMutation__
+ *
+ * To run a mutation, you first call `useAddInviteCodesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddInviteCodesMutation` 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 [addInviteCodesMutation, { data, loading, error }] = useAddInviteCodesMutation({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      codesNum: // value for 'codesNum'
+ *   },
+ * });
+ */
+export function useAddInviteCodesMutation(baseOptions?: Apollo.MutationHookOptions<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>) {
+        return Apollo.useMutation<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>(AddInviteCodesDocument, baseOptions);
+      }
+export type AddInviteCodesMutationHookResult = ReturnType<typeof useAddInviteCodesMutation>;
+export type AddInviteCodesMutationResult = Apollo.MutationResult<IAddInviteCodesMutation>;
+export type AddInviteCodesMutationOptions = Apollo.BaseMutationOptions<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>;
+export const RemoveInviteCodeDocument = gql`
+    mutation RemoveInviteCode($inviteCode: String!) {
+  removeInviteCode(inviteCode: $inviteCode)
+}
+    `;
+export type IRemoveInviteCodeMutationFn = Apollo.MutationFunction<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>;
+
+/**
+ * __useRemoveInviteCodeMutation__
+ *
+ * To run a mutation, you first call `useRemoveInviteCodeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveInviteCodeMutation` 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 [removeInviteCodeMutation, { data, loading, error }] = useRemoveInviteCodeMutation({
+ *   variables: {
+ *      inviteCode: // value for 'inviteCode'
+ *   },
+ * });
+ */
+export function useRemoveInviteCodeMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>) {
+        return Apollo.useMutation<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>(RemoveInviteCodeDocument, baseOptions);
+      }
+export type RemoveInviteCodeMutationHookResult = ReturnType<typeof useRemoveInviteCodeMutation>;
+export type RemoveInviteCodeMutationResult = Apollo.MutationResult<IRemoveInviteCodeMutation>;
+export type RemoveInviteCodeMutationOptions = Apollo.BaseMutationOptions<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>;
+export const UpdateProfileStatusDocument = gql`
+    mutation UpdateProfileStatus($userId: ID!, $isActive: Boolean!) {
+  updateProfileStatus(userId: $userId, isActive: $isActive)
+}
+    `;
+export type IUpdateProfileStatusMutationFn = Apollo.MutationFunction<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>;
+
+/**
+ * __useUpdateProfileStatusMutation__
+ *
+ * To run a mutation, you first call `useUpdateProfileStatusMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProfileStatusMutation` 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 [updateProfileStatusMutation, { data, loading, error }] = useUpdateProfileStatusMutation({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *      isActive: // value for 'isActive'
+ *   },
+ * });
+ */
+export function useUpdateProfileStatusMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>) {
+        return Apollo.useMutation<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>(UpdateProfileStatusDocument, baseOptions);
+      }
+export type UpdateProfileStatusMutationHookResult = ReturnType<typeof useUpdateProfileStatusMutation>;
+export type UpdateProfileStatusMutationResult = Apollo.MutationResult<IUpdateProfileStatusMutation>;
+export type UpdateProfileStatusMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>;
+export const FetchAdminBrandsDocument = gql`
+    query FetchAdminBrands {
+  fetchAdminBrands {
+    id
+    name
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminBrandsQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminBrandsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminBrandsQuery` 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 } = useFetchAdminBrandsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchAdminBrandsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>(FetchAdminBrandsDocument, baseOptions);
+      }
+export function useFetchAdminBrandsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>(FetchAdminBrandsDocument, baseOptions);
+        }
+export type FetchAdminBrandsQueryHookResult = ReturnType<typeof useFetchAdminBrandsQuery>;
+export type FetchAdminBrandsLazyQueryHookResult = ReturnType<typeof useFetchAdminBrandsLazyQuery>;
+export type FetchAdminBrandsQueryResult = Apollo.QueryResult<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>;
+export const FetchAdminBrandsPageDocument = gql`
+    query FetchAdminBrandsPage($filter: BrandsFilterInput!, $sort: BrandsSortInput!, $page: AdminPageInput!) {
+  fetchAdminBrandsPage(filter: $filter, sort: $sort, page: $page) {
+    brands {
+      description
+      id
+      industry
+      link
+      matchingWords
+      media
+      name
+      archived
+      addedBy
+    }
+    nextPage {
+      num
+      lastNum
+      size
+      elements
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminBrandsPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminBrandsPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminBrandsPageQuery` 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 } = useFetchAdminBrandsPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminBrandsPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>(FetchAdminBrandsPageDocument, baseOptions);
+      }
+export function useFetchAdminBrandsPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>(FetchAdminBrandsPageDocument, baseOptions);
+        }
+export type FetchAdminBrandsPageQueryHookResult = ReturnType<typeof useFetchAdminBrandsPageQuery>;
+export type FetchAdminBrandsPageLazyQueryHookResult = ReturnType<typeof useFetchAdminBrandsPageLazyQuery>;
+export type FetchAdminBrandsPageQueryResult = Apollo.QueryResult<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>;
+export const FetchAdminCategoriesDocument = gql`
+    query FetchAdminCategories {
+  fetchAdminCategories {
+    id
+    name
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminCategoriesQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminCategoriesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminCategoriesQuery` 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 } = useFetchAdminCategoriesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchAdminCategoriesQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>(FetchAdminCategoriesDocument, baseOptions);
+      }
+export function useFetchAdminCategoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>(FetchAdminCategoriesDocument, baseOptions);
+        }
+export type FetchAdminCategoriesQueryHookResult = ReturnType<typeof useFetchAdminCategoriesQuery>;
+export type FetchAdminCategoriesLazyQueryHookResult = ReturnType<typeof useFetchAdminCategoriesLazyQuery>;
+export type FetchAdminCategoriesQueryResult = Apollo.QueryResult<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>;
+export const FetchAdminCategoriesPageDocument = gql`
+    query FetchAdminCategoriesPage($filter: CategoriesFilterInput!, $sort: CategoriesSortInput!, $page: AdminPageInput!) {
+  fetchAdminCategoriesPage(filter: $filter, sort: $sort, page: $page) {
+    categories {
+      id
+      name
+      matchingWords
+      archived
+      addedBy
+    }
+    nextPage {
+      num
+      lastNum
+      size
+      elements
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminCategoriesPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminCategoriesPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminCategoriesPageQuery` 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 } = useFetchAdminCategoriesPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminCategoriesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>(FetchAdminCategoriesPageDocument, baseOptions);
+      }
+export function useFetchAdminCategoriesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>(FetchAdminCategoriesPageDocument, baseOptions);
+        }
+export type FetchAdminCategoriesPageQueryHookResult = ReturnType<typeof useFetchAdminCategoriesPageQuery>;
+export type FetchAdminCategoriesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminCategoriesPageLazyQuery>;
+export type FetchAdminCategoriesPageQueryResult = Apollo.QueryResult<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>;
+export const FetchAdminInvitesPageDocument = gql`
+    query fetchAdminInvitesPage($filter: InvitesFilterInput!, $sort: InvitesSortInput!, $page: AdminPageInput!) {
+  fetchAdminInvitesPage(filter: $filter, sort: $sort, page: $page) {
+    invites {
+      userId
+      username
+      wallet {
+        address
+        blockchain
+        chainId
+      }
+      activeInvites {
+        inviteCode
+        createdAt
+      }
+      referredUsers
+      userXpLevel
+    }
+    nextPage {
+      num
+      lastNum
+      size
+      elements
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminInvitesPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminInvitesPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminInvitesPageQuery` 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 } = useFetchAdminInvitesPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminInvitesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>(FetchAdminInvitesPageDocument, baseOptions);
+      }
+export function useFetchAdminInvitesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>(FetchAdminInvitesPageDocument, baseOptions);
+        }
+export type FetchAdminInvitesPageQueryHookResult = ReturnType<typeof useFetchAdminInvitesPageQuery>;
+export type FetchAdminInvitesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminInvitesPageLazyQuery>;
+export type FetchAdminInvitesPageQueryResult = Apollo.QueryResult<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>;
+export const FetchAdminOpportunitiesPageDocument = gql`
+    query FetchAdminOpportunitiesPage($filter: OpportunitiesFilterInput!, $sort: OpportunitiesSortInput!, $page: AdminPageInput!) {
+  fetchAdminOpportunitiesPage(filter: $filter, sort: $sort, page: $page) {
+    opportunities {
+      opportunityId
+      name
+      brandName
+      industry
+      category
+      ludoUrl
+      projectUrl
+      pushNotificationsEnabled
+      status
+      media
+      description
+      activeFrom
+      activeUntil
+      minXpLevel
+      maxXpLevel
+      minLudoRank
+      maxLudoRank
+      minWalletValue
+      maxWalletValue
+      clicks
+      views
+      addedBy
+    }
+    nextPage {
+      elements
+      lastNum
+      num
+      size
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminOpportunitiesPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminOpportunitiesPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminOpportunitiesPageQuery` 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 } = useFetchAdminOpportunitiesPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminOpportunitiesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>(FetchAdminOpportunitiesPageDocument, baseOptions);
+      }
+export function useFetchAdminOpportunitiesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>(FetchAdminOpportunitiesPageDocument, baseOptions);
+        }
+export type FetchAdminOpportunitiesPageQueryHookResult = ReturnType<typeof useFetchAdminOpportunitiesPageQuery>;
+export type FetchAdminOpportunitiesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminOpportunitiesPageLazyQuery>;
+export type FetchAdminOpportunitiesPageQueryResult = Apollo.QueryResult<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>;
+export const FetchAdminReferralsPageDocument = gql`
+    query FetchAdminReferralsPage($filter: ReferralsFilterInput!, $sort: ReferralsSortInput!, $page: AdminPageInput!) {
+  fetchAdminReferralsPage(filter: $filter, sort: $sort, page: $page) {
+    adminReferrals {
+      userId
+      username
+      mainWallet {
+        address
+        blockchain
+        chainId
+      }
+      referredUsersNum
+      referrals {
+        userRefUrl
+        opportunityUrl
+        referredUsersPerUrlNum
+      }
+    }
+    nextPage {
+      elements
+      lastNum
+      num
+      size
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminReferralsPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminReferralsPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminReferralsPageQuery` 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 } = useFetchAdminReferralsPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminReferralsPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>(FetchAdminReferralsPageDocument, baseOptions);
+      }
+export function useFetchAdminReferralsPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>(FetchAdminReferralsPageDocument, baseOptions);
+        }
+export type FetchAdminReferralsPageQueryHookResult = ReturnType<typeof useFetchAdminReferralsPageQuery>;
+export type FetchAdminReferralsPageLazyQueryHookResult = ReturnType<typeof useFetchAdminReferralsPageLazyQuery>;
+export type FetchAdminReferralsPageQueryResult = Apollo.QueryResult<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>;
+export const FetchAdminUsersPageDocument = gql`
+    query fetchAdminUsersPage($filter: UsersFilterInput!, $sort: UsersSortInput!, $page: AdminPageInput!) {
+  fetchAdminUsersPage(filter: $filter, sort: $sort, page: $page) {
+    users {
+      userId
+      username
+      wallets {
+        address
+        blockchain
+        chainId
+      }
+      connectedBlockchains
+      isActive
+      createdAt
+      topInterests
+      walletsValue
+      xpLevel
+      ludoRank
+      inviterId
+    }
+    nextPage {
+      num
+      lastNum
+      size
+      elements
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminUsersPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminUsersPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminUsersPageQuery` 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 } = useFetchAdminUsersPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminUsersPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>(FetchAdminUsersPageDocument, baseOptions);
+      }
+export function useFetchAdminUsersPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>(FetchAdminUsersPageDocument, baseOptions);
+        }
+export type FetchAdminUsersPageQueryHookResult = ReturnType<typeof useFetchAdminUsersPageQuery>;
+export type FetchAdminUsersPageLazyQueryHookResult = ReturnType<typeof useFetchAdminUsersPageLazyQuery>;
+export type FetchAdminUsersPageQueryResult = Apollo.QueryResult<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>;
+export const FetchAdminXpPageDocument = gql`
+    query FetchAdminXpPage($filter: XpFilterInput!, $sort: XpSortInput!, $page: AdminPageInput!) {
+  fetchAdminXpPage(filter: $filter, sort: $sort, page: $page) {
+    xps {
+      userId
+      username
+      mainWallet {
+        address
+        blockchain
+        chainId
+      }
+      userXpLevel
+      userXpPoints
+      referredUsers
+      referredUsersNum
+      joinedOpportunityIds
+      connectedWalletsNum
+      suggestedOpportunityIds
+    }
+    nextPage {
+      elements
+      lastNum
+      num
+      size
+      token
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchAdminXpPageQuery__
+ *
+ * To run a query within a React component, call `useFetchAdminXpPageQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchAdminXpPageQuery` 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 } = useFetchAdminXpPageQuery({
+ *   variables: {
+ *      filter: // value for 'filter'
+ *      sort: // value for 'sort'
+ *      page: // value for 'page'
+ *   },
+ * });
+ */
+export function useFetchAdminXpPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>) {
+        return Apollo.useQuery<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>(FetchAdminXpPageDocument, baseOptions);
+      }
+export function useFetchAdminXpPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>(FetchAdminXpPageDocument, baseOptions);
+        }
+export type FetchAdminXpPageQueryHookResult = ReturnType<typeof useFetchAdminXpPageQuery>;
+export type FetchAdminXpPageLazyQueryHookResult = ReturnType<typeof useFetchAdminXpPageLazyQuery>;
+export type FetchAdminXpPageQueryResult = Apollo.QueryResult<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>;
+export const FetchBlockchainsDocument = gql`
+    query FetchBlockchains {
+  fetchBlockchains
+}
+    `;
+
+/**
+ * __useFetchBlockchainsQuery__
+ *
+ * To run a query within a React component, call `useFetchBlockchainsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchBlockchainsQuery` 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 } = useFetchBlockchainsQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchBlockchainsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>) {
+        return Apollo.useQuery<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>(FetchBlockchainsDocument, baseOptions);
+      }
+export function useFetchBlockchainsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>(FetchBlockchainsDocument, baseOptions);
+        }
+export type FetchBlockchainsQueryHookResult = ReturnType<typeof useFetchBlockchainsQuery>;
+export type FetchBlockchainsLazyQueryHookResult = ReturnType<typeof useFetchBlockchainsLazyQuery>;
+export type FetchBlockchainsQueryResult = Apollo.QueryResult<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>;