@ludo.ninja/api 2.8.28 → 2.8.30

package/build/graphql_tools/__generated__/adminHost/schema.d.ts

@@ -0,0 +1,1434 @@
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+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 declare 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 declare const ChangeXpPointsDocument: Apollo.DocumentNode;
+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 declare function useChangeXpPointsMutation(baseOptions?: Apollo.MutationHookOptions<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>): Apollo.MutationTuple<IChangeXpPointsMutation, Exact<{
+    userId: string;
+    pointsDiff: number;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ChangeXpPointsMutationHookResult = ReturnType<typeof useChangeXpPointsMutation>;
+export type ChangeXpPointsMutationResult = Apollo.MutationResult<IChangeXpPointsMutation>;
+export type ChangeXpPointsMutationOptions = Apollo.BaseMutationOptions<IChangeXpPointsMutation, IChangeXpPointsMutationVariables>;
+export declare const CreateCategoryDocument: Apollo.DocumentNode;
+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 declare function useCreateCategoryMutation(baseOptions?: Apollo.MutationHookOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>): Apollo.MutationTuple<ICreateCategoryMutation, Exact<{
+    name: string;
+    matchingWords: string[];
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateCategoryMutationHookResult = ReturnType<typeof useCreateCategoryMutation>;
+export type CreateCategoryMutationResult = Apollo.MutationResult<ICreateCategoryMutation>;
+export type CreateCategoryMutationOptions = Apollo.BaseMutationOptions<ICreateCategoryMutation, ICreateCategoryMutationVariables>;
+export declare const CreateBrandDocument: Apollo.DocumentNode;
+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 declare function useCreateBrandMutation(baseOptions?: Apollo.MutationHookOptions<ICreateBrandMutation, ICreateBrandMutationVariables>): Apollo.MutationTuple<ICreateBrandMutation, Exact<{
+    brand: IBrandInput;
+    file?: any;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateBrandMutationHookResult = ReturnType<typeof useCreateBrandMutation>;
+export type CreateBrandMutationResult = Apollo.MutationResult<ICreateBrandMutation>;
+export type CreateBrandMutationOptions = Apollo.BaseMutationOptions<ICreateBrandMutation, ICreateBrandMutationVariables>;
+export declare const CreateAdminOpportunityDocument: Apollo.DocumentNode;
+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 declare function useCreateAdminOpportunityMutation(baseOptions?: Apollo.MutationHookOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>): Apollo.MutationTuple<ICreateAdminOpportunityMutation, Exact<{
+    file?: any;
+    input: IAdminOpportunityInput;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateAdminOpportunityMutationHookResult = ReturnType<typeof useCreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationResult = Apollo.MutationResult<ICreateAdminOpportunityMutation>;
+export type CreateAdminOpportunityMutationOptions = Apollo.BaseMutationOptions<ICreateAdminOpportunityMutation, ICreateAdminOpportunityMutationVariables>;
+export declare const AddInviteCodesDocument: Apollo.DocumentNode;
+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 declare function useAddInviteCodesMutation(baseOptions?: Apollo.MutationHookOptions<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>): Apollo.MutationTuple<IAddInviteCodesMutation, Exact<{
+    userId: string;
+    codesNum: number;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddInviteCodesMutationHookResult = ReturnType<typeof useAddInviteCodesMutation>;
+export type AddInviteCodesMutationResult = Apollo.MutationResult<IAddInviteCodesMutation>;
+export type AddInviteCodesMutationOptions = Apollo.BaseMutationOptions<IAddInviteCodesMutation, IAddInviteCodesMutationVariables>;
+export declare const RemoveInviteCodeDocument: Apollo.DocumentNode;
+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 declare function useRemoveInviteCodeMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>): Apollo.MutationTuple<IRemoveInviteCodeMutation, Exact<{
+    inviteCode: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveInviteCodeMutationHookResult = ReturnType<typeof useRemoveInviteCodeMutation>;
+export type RemoveInviteCodeMutationResult = Apollo.MutationResult<IRemoveInviteCodeMutation>;
+export type RemoveInviteCodeMutationOptions = Apollo.BaseMutationOptions<IRemoveInviteCodeMutation, IRemoveInviteCodeMutationVariables>;
+export declare const UpdateProfileStatusDocument: Apollo.DocumentNode;
+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 declare function useUpdateProfileStatusMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>): Apollo.MutationTuple<IUpdateProfileStatusMutation, Exact<{
+    userId: string;
+    isActive: boolean;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateProfileStatusMutationHookResult = ReturnType<typeof useUpdateProfileStatusMutation>;
+export type UpdateProfileStatusMutationResult = Apollo.MutationResult<IUpdateProfileStatusMutation>;
+export type UpdateProfileStatusMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileStatusMutation, IUpdateProfileStatusMutationVariables>;
+export declare const FetchAdminBrandsDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminBrandsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>): Apollo.QueryResult<IFetchAdminBrandsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchAdminBrandsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminBrandsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchAdminBrandsQueryHookResult = ReturnType<typeof useFetchAdminBrandsQuery>;
+export type FetchAdminBrandsLazyQueryHookResult = ReturnType<typeof useFetchAdminBrandsLazyQuery>;
+export type FetchAdminBrandsQueryResult = Apollo.QueryResult<IFetchAdminBrandsQuery, IFetchAdminBrandsQueryVariables>;
+export declare const FetchAdminBrandsPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminBrandsPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>): Apollo.QueryResult<IFetchAdminBrandsPageQuery, Exact<{
+    filter: IBrandsFilterInput;
+    sort: IBrandsSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminBrandsPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminBrandsPageQuery, Exact<{
+    filter: IBrandsFilterInput;
+    sort: IBrandsSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminBrandsPageQueryHookResult = ReturnType<typeof useFetchAdminBrandsPageQuery>;
+export type FetchAdminBrandsPageLazyQueryHookResult = ReturnType<typeof useFetchAdminBrandsPageLazyQuery>;
+export type FetchAdminBrandsPageQueryResult = Apollo.QueryResult<IFetchAdminBrandsPageQuery, IFetchAdminBrandsPageQueryVariables>;
+export declare const FetchAdminCategoriesDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminCategoriesQuery(baseOptions?: Apollo.QueryHookOptions<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>): Apollo.QueryResult<IFetchAdminCategoriesQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchAdminCategoriesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminCategoriesQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchAdminCategoriesQueryHookResult = ReturnType<typeof useFetchAdminCategoriesQuery>;
+export type FetchAdminCategoriesLazyQueryHookResult = ReturnType<typeof useFetchAdminCategoriesLazyQuery>;
+export type FetchAdminCategoriesQueryResult = Apollo.QueryResult<IFetchAdminCategoriesQuery, IFetchAdminCategoriesQueryVariables>;
+export declare const FetchAdminCategoriesPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminCategoriesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>): Apollo.QueryResult<IFetchAdminCategoriesPageQuery, Exact<{
+    filter: ICategoriesFilterInput;
+    sort: ICategoriesSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminCategoriesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminCategoriesPageQuery, Exact<{
+    filter: ICategoriesFilterInput;
+    sort: ICategoriesSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminCategoriesPageQueryHookResult = ReturnType<typeof useFetchAdminCategoriesPageQuery>;
+export type FetchAdminCategoriesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminCategoriesPageLazyQuery>;
+export type FetchAdminCategoriesPageQueryResult = Apollo.QueryResult<IFetchAdminCategoriesPageQuery, IFetchAdminCategoriesPageQueryVariables>;
+export declare const FetchAdminInvitesPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminInvitesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>): Apollo.QueryResult<IFetchAdminInvitesPageQuery, Exact<{
+    filter: IInvitesFilterInput;
+    sort: IInvitesSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminInvitesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminInvitesPageQuery, Exact<{
+    filter: IInvitesFilterInput;
+    sort: IInvitesSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminInvitesPageQueryHookResult = ReturnType<typeof useFetchAdminInvitesPageQuery>;
+export type FetchAdminInvitesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminInvitesPageLazyQuery>;
+export type FetchAdminInvitesPageQueryResult = Apollo.QueryResult<IFetchAdminInvitesPageQuery, IFetchAdminInvitesPageQueryVariables>;
+export declare const FetchAdminOpportunitiesPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminOpportunitiesPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>): Apollo.QueryResult<IFetchAdminOpportunitiesPageQuery, Exact<{
+    filter: IOpportunitiesFilterInput;
+    sort: IOpportunitiesSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminOpportunitiesPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminOpportunitiesPageQuery, Exact<{
+    filter: IOpportunitiesFilterInput;
+    sort: IOpportunitiesSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminOpportunitiesPageQueryHookResult = ReturnType<typeof useFetchAdminOpportunitiesPageQuery>;
+export type FetchAdminOpportunitiesPageLazyQueryHookResult = ReturnType<typeof useFetchAdminOpportunitiesPageLazyQuery>;
+export type FetchAdminOpportunitiesPageQueryResult = Apollo.QueryResult<IFetchAdminOpportunitiesPageQuery, IFetchAdminOpportunitiesPageQueryVariables>;
+export declare const FetchAdminReferralsPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminReferralsPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>): Apollo.QueryResult<IFetchAdminReferralsPageQuery, Exact<{
+    filter: IReferralsFilterInput;
+    sort: IReferralsSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminReferralsPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminReferralsPageQuery, Exact<{
+    filter: IReferralsFilterInput;
+    sort: IReferralsSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminReferralsPageQueryHookResult = ReturnType<typeof useFetchAdminReferralsPageQuery>;
+export type FetchAdminReferralsPageLazyQueryHookResult = ReturnType<typeof useFetchAdminReferralsPageLazyQuery>;
+export type FetchAdminReferralsPageQueryResult = Apollo.QueryResult<IFetchAdminReferralsPageQuery, IFetchAdminReferralsPageQueryVariables>;
+export declare const FetchAdminUsersPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminUsersPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>): Apollo.QueryResult<IFetchAdminUsersPageQuery, Exact<{
+    filter: IUsersFilterInput;
+    sort: IUsersSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminUsersPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminUsersPageQuery, Exact<{
+    filter: IUsersFilterInput;
+    sort: IUsersSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminUsersPageQueryHookResult = ReturnType<typeof useFetchAdminUsersPageQuery>;
+export type FetchAdminUsersPageLazyQueryHookResult = ReturnType<typeof useFetchAdminUsersPageLazyQuery>;
+export type FetchAdminUsersPageQueryResult = Apollo.QueryResult<IFetchAdminUsersPageQuery, IFetchAdminUsersPageQueryVariables>;
+export declare const FetchAdminXpPageDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchAdminXpPageQuery(baseOptions: Apollo.QueryHookOptions<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>): Apollo.QueryResult<IFetchAdminXpPageQuery, Exact<{
+    filter: IXpFilterInput;
+    sort: IXpSortInput;
+    page: IAdminPageInput;
+}>>;
+export declare function useFetchAdminXpPageLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAdminXpPageQuery, Exact<{
+    filter: IXpFilterInput;
+    sort: IXpSortInput;
+    page: IAdminPageInput;
+}>>;
+export type FetchAdminXpPageQueryHookResult = ReturnType<typeof useFetchAdminXpPageQuery>;
+export type FetchAdminXpPageLazyQueryHookResult = ReturnType<typeof useFetchAdminXpPageLazyQuery>;
+export type FetchAdminXpPageQueryResult = Apollo.QueryResult<IFetchAdminXpPageQuery, IFetchAdminXpPageQueryVariables>;
+export declare const FetchBlockchainsDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchBlockchainsQuery(baseOptions?: Apollo.QueryHookOptions<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>): Apollo.QueryResult<IFetchBlockchainsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchBlockchainsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchBlockchainsQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchBlockchainsQueryHookResult = ReturnType<typeof useFetchBlockchainsQuery>;
+export type FetchBlockchainsLazyQueryHookResult = ReturnType<typeof useFetchBlockchainsLazyQuery>;
+export type FetchBlockchainsQueryResult = Apollo.QueryResult<IFetchBlockchainsQuery, IFetchBlockchainsQueryVariables>;