@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,1584 @@
+/* eslint-disable */
+import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
+import { gql } from '@apollo/client';
+import * as Apollo from '@apollo/client';
+export type Maybe<T> = T | null;
+export type Exact<T extends { [key: string]: unknown }> = { [K in keyof T]: T[K] };
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]?: Maybe<T[SubKey]> };
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & { [SubKey in K]: Maybe<T[SubKey]> };
+export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+  ID: string;
+  String: string;
+  Boolean: boolean;
+  Int: number;
+  Float: number;
+  /** A 64-bit signed integer */
+  Long: any;
+};
+
+
+
+
+
+
+export type IFollowingStatus = {
+  userId: Scalars['ID'];
+  following: Scalars['Boolean'];
+};
+
+export type IIdentity = {
+  userId: Scalars['ID'];
+  wallets: Array<Maybe<Scalars['String']>>;
+  authToken: Scalars['String'];
+  refreshToken: Scalars['String'];
+  tokens: ITokenPairs;
+  role: IRole;
+  newUser?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+export type IInputProfile = {
+  username?: Maybe<Scalars['String']>;
+  about?: Maybe<Scalars['String']>;
+  social?: Maybe<IInputSocial>;
+  showNsfw?: Maybe<Scalars['Boolean']>;
+};
+
+export type IInputSocial = {
+  facebook?: Maybe<Scalars['String']>;
+  twitter?: Maybe<Scalars['String']>;
+  instagram?: Maybe<Scalars['String']>;
+  website?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  createNonce: Scalars['String'];
+  signInAdminMetamask: IIdentity;
+  signInMetamask: IIdentity;
+  signInTezos: IIdentity;
+  signInSolana: IIdentity;
+  signInElrond: IIdentity;
+  signInFlow: IIdentity;
+  addWalletMetamask: Scalars['Boolean'];
+  addWalletTezos: Scalars['Boolean'];
+  addWalletSolana: Scalars['Boolean'];
+  addWalletElrond: Scalars['Boolean'];
+  addWalletFlow: Scalars['Boolean'];
+  removeWallet: Scalars['Boolean'];
+  setMainWallet: Scalars['Boolean'];
+  generateNewInviteCodes: Array<IUserInviteCode>;
+  saveEmailOfJoiner: Scalars['Boolean'];
+  useInviteCode: Scalars['Boolean'];
+  updateProfile: Scalars['Boolean'];
+  followProfile: Scalars['Boolean'];
+  unfollowProfile: Scalars['Boolean'];
+};
+
+
+export type IMutationCreateNonceArgs = {
+  address: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSignInAdminMetamaskArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+};
+
+
+export type IMutationSignInMetamaskArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+  restore?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSignInTezosArgs = {
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+  restore?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSignInSolanaArgs = {
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+  restore?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSignInElrondArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  restore?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSignInFlowArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  restore?: Maybe<Scalars['Boolean']>;
+  inviteCode?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationAddWalletMetamaskArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+};
+
+
+export type IMutationAddWalletTezosArgs = {
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+};
+
+
+export type IMutationAddWalletSolanaArgs = {
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+};
+
+
+export type IMutationAddWalletElrondArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+};
+
+
+export type IMutationAddWalletFlowArgs = {
+  signature: Scalars['String'];
+  address: Scalars['String'];
+};
+
+
+export type IMutationRemoveWalletArgs = {
+  blockchain: Scalars['String'];
+  address: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationSetMainWalletArgs = {
+  blockchain: Scalars['String'];
+  address: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+};
+
+
+export type IMutationGenerateNewInviteCodesArgs = {
+  codesNum: Scalars['Int'];
+};
+
+
+export type IMutationSaveEmailOfJoinerArgs = {
+  email: Scalars['String'];
+  isSubscribed: Scalars['Boolean'];
+};
+
+
+export type IMutationUseInviteCodeArgs = {
+  inviteCode: Scalars['String'];
+};
+
+
+export type IMutationUpdateProfileArgs = {
+  profile?: Maybe<IInputProfile>;
+};
+
+
+export type IMutationFollowProfileArgs = {
+  followingUserId: Scalars['ID'];
+};
+
+
+export type IMutationUnfollowProfileArgs = {
+  followingUserId: Scalars['ID'];
+};
+
+export type IProfile = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  about?: Maybe<Scalars['String']>;
+  userpic?: Maybe<Scalars['String']>;
+  following?: Maybe<Scalars['Boolean']>;
+  followings?: Maybe<Scalars['Int']>;
+  followers?: Maybe<Scalars['Int']>;
+  social?: Maybe<ISocial>;
+  views?: Maybe<Scalars['Int']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  deletedAt?: Maybe<Scalars['Long']>;
+  visible?: Maybe<Scalars['Boolean']>;
+  deleted?: Maybe<Scalars['Boolean']>;
+  showNsfw?: Maybe<Scalars['Boolean']>;
+  rank?: Maybe<Scalars['Float']>;
+  wallets?: Maybe<Array<Maybe<IWallet>>>;
+  xps?: Maybe<Scalars['Int']>;
+  level?: Maybe<Scalars['Int']>;
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchUserWallets: Array<Maybe<IWallet>>;
+  isInviteCodeAvailable: Scalars['Boolean'];
+  getMyInviteCodes: Array<IUserInviteCode>;
+  fetchProfile: IProfile;
+  fetchFollowingStatus: IFollowingStatus;
+  fetchFollowingStatuses: Array<Maybe<IFollowingStatus>>;
+};
+
+
+export type IQueryFetchUserWalletsArgs = {
+  userId: Scalars['ID'];
+};
+
+
+export type IQueryIsInviteCodeAvailableArgs = {
+  inviteCode: Scalars['String'];
+};
+
+
+export type IQueryFetchProfileArgs = {
+  userId: Scalars['ID'];
+};
+
+
+export type IQueryFetchFollowingStatusArgs = {
+  userId: Scalars['ID'];
+};
+
+
+export type IQueryFetchFollowingStatusesArgs = {
+  userIds: Array<Scalars['ID']>;
+};
+
+export enum IRole {
+  Admin = 'admin',
+  Plain = 'plain'
+}
+
+export type ISocial = {
+  facebook?: Maybe<Scalars['String']>;
+  twitter?: Maybe<Scalars['String']>;
+  instagram?: Maybe<Scalars['String']>;
+  website?: Maybe<Scalars['String']>;
+};
+
+export type ITokenPair = {
+  authToken: Scalars['String'];
+  refreshToken: Scalars['String'];
+};
+
+export type ITokenPairs = {
+  portalTokenPair: ITokenPair;
+  extensionTokenPair: ITokenPair;
+};
+
+export type IUserInviteCode = {
+  inviteCode: Scalars['String'];
+  inviteeId?: Maybe<Scalars['ID']>;
+  isUsed: Scalars['Boolean'];
+  usedAt?: Maybe<Scalars['Long']>;
+};
+
+export type IWallet = {
+  userId: Scalars['ID'];
+  address: Scalars['String'];
+  walletName: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+  mainWallet: Scalars['Boolean'];
+};
+
+
+
+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 = {
+  FollowingStatus: ResolverTypeWrapper<IFollowingStatus>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Identity: ResolverTypeWrapper<IIdentity>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  InputProfile: IInputProfile;
+  InputSocial: IInputSocial;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  Profile: ResolverTypeWrapper<IProfile>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  Query: ResolverTypeWrapper<{}>;
+  Role: IRole;
+  Social: ResolverTypeWrapper<ISocial>;
+  TokenPair: ResolverTypeWrapper<ITokenPair>;
+  TokenPairs: ResolverTypeWrapper<ITokenPairs>;
+  UserInviteCode: ResolverTypeWrapper<IUserInviteCode>;
+  Wallet: ResolverTypeWrapper<IWallet>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  FollowingStatus: IFollowingStatus;
+  ID: Scalars['ID'];
+  Boolean: Scalars['Boolean'];
+  Identity: IIdentity;
+  String: Scalars['String'];
+  InputProfile: IInputProfile;
+  InputSocial: IInputSocial;
+  Long: Scalars['Long'];
+  Mutation: {};
+  Int: Scalars['Int'];
+  Profile: IProfile;
+  Float: Scalars['Float'];
+  Query: {};
+  Social: ISocial;
+  TokenPair: ITokenPair;
+  TokenPairs: ITokenPairs;
+  UserInviteCode: IUserInviteCode;
+  Wallet: IWallet;
+};
+
+export type IPatternDirectiveArgs = {
+  regexp: Scalars['String'];
+  message?: Maybe<Scalars['String']>;
+};
+
+export type IPatternDirectiveResolver<Result, Parent, ContextType = any, Args = IPatternDirectiveArgs> = 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 ISizeDirectiveArgs = {
+  min?: Maybe<Scalars['Int']>;
+  max?: Maybe<Scalars['Int']>;
+  message?: Maybe<Scalars['String']>;
+};
+
+export type ISizeDirectiveResolver<Result, Parent, ContextType = any, Args = ISizeDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IConnectionDirectiveArgs = {
+  for: Scalars['String'];
+};
+
+export type IConnectionDirectiveResolver<Result, Parent, ContextType = any, Args = IConnectionDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IFollowingStatusResolvers<ContextType = any, ParentType extends IResolversParentTypes['FollowingStatus'] = IResolversParentTypes['FollowingStatus']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  following?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IIdentityResolvers<ContextType = any, ParentType extends IResolversParentTypes['Identity'] = IResolversParentTypes['Identity']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  wallets?: Resolver<Array<Maybe<IResolversTypes['String']>>, ParentType, ContextType>;
+  authToken?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  refreshToken?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  tokens?: Resolver<IResolversTypes['TokenPairs'], ParentType, ContextType>;
+  role?: Resolver<IResolversTypes['Role'], ParentType, ContextType>;
+  newUser?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  inviteCode?: Resolver<Maybe<IResolversTypes['String']>, 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>;
+  createNonce?: Resolver<IResolversTypes['String'], ParentType, ContextType, RequireFields<IMutationCreateNonceArgs, 'address' | 'blockchain'>>;
+  signInAdminMetamask?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInAdminMetamaskArgs, 'signature' | 'address' | 'chainId'>>;
+  signInMetamask?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInMetamaskArgs, 'signature' | 'address' | 'chainId'>>;
+  signInTezos?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInTezosArgs, 'signature' | 'pubkey'>>;
+  signInSolana?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInSolanaArgs, 'signature' | 'pubkey'>>;
+  signInElrond?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInElrondArgs, 'signature' | 'address'>>;
+  signInFlow?: Resolver<IResolversTypes['Identity'], ParentType, ContextType, RequireFields<IMutationSignInFlowArgs, 'signature' | 'address'>>;
+  addWalletMetamask?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddWalletMetamaskArgs, 'signature' | 'address' | 'chainId'>>;
+  addWalletTezos?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddWalletTezosArgs, 'signature' | 'pubkey'>>;
+  addWalletSolana?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddWalletSolanaArgs, 'signature' | 'pubkey'>>;
+  addWalletElrond?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddWalletElrondArgs, 'signature' | 'address'>>;
+  addWalletFlow?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddWalletFlowArgs, 'signature' | 'address'>>;
+  removeWallet?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationRemoveWalletArgs, 'blockchain' | 'address'>>;
+  setMainWallet?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSetMainWalletArgs, 'blockchain' | 'address'>>;
+  generateNewInviteCodes?: Resolver<Array<IResolversTypes['UserInviteCode']>, ParentType, ContextType, RequireFields<IMutationGenerateNewInviteCodesArgs, 'codesNum'>>;
+  saveEmailOfJoiner?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationSaveEmailOfJoinerArgs, 'email' | 'isSubscribed'>>;
+  useInviteCode?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUseInviteCodeArgs, 'inviteCode'>>;
+  updateProfile?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, Partial<IMutationUpdateProfileArgs>>;
+  followProfile?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationFollowProfileArgs, 'followingUserId'>>;
+  unfollowProfile?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUnfollowProfileArgs, 'followingUserId'>>;
+};
+
+export type IProfileResolvers<ContextType = any, ParentType extends IResolversParentTypes['Profile'] = IResolversParentTypes['Profile']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  about?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  userpic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  following?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  followings?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  followers?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  social?: Resolver<Maybe<IResolversTypes['Social']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  deletedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  deleted?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  showNsfw?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  wallets?: Resolver<Maybe<Array<Maybe<IResolversTypes['Wallet']>>>, ParentType, ContextType>;
+  xps?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  level?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchUserWallets?: Resolver<Array<Maybe<IResolversTypes['Wallet']>>, ParentType, ContextType, RequireFields<IQueryFetchUserWalletsArgs, 'userId'>>;
+  isInviteCodeAvailable?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IQueryIsInviteCodeAvailableArgs, 'inviteCode'>>;
+  getMyInviteCodes?: Resolver<Array<IResolversTypes['UserInviteCode']>, ParentType, ContextType>;
+  fetchProfile?: Resolver<IResolversTypes['Profile'], ParentType, ContextType, RequireFields<IQueryFetchProfileArgs, 'userId'>>;
+  fetchFollowingStatus?: Resolver<IResolversTypes['FollowingStatus'], ParentType, ContextType, RequireFields<IQueryFetchFollowingStatusArgs, 'userId'>>;
+  fetchFollowingStatuses?: Resolver<Array<Maybe<IResolversTypes['FollowingStatus']>>, ParentType, ContextType, RequireFields<IQueryFetchFollowingStatusesArgs, 'userIds'>>;
+};
+
+export type ISocialResolvers<ContextType = any, ParentType extends IResolversParentTypes['Social'] = IResolversParentTypes['Social']> = {
+  facebook?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  twitter?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  instagram?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  website?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ITokenPairResolvers<ContextType = any, ParentType extends IResolversParentTypes['TokenPair'] = IResolversParentTypes['TokenPair']> = {
+  authToken?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  refreshToken?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ITokenPairsResolvers<ContextType = any, ParentType extends IResolversParentTypes['TokenPairs'] = IResolversParentTypes['TokenPairs']> = {
+  portalTokenPair?: Resolver<IResolversTypes['TokenPair'], ParentType, ContextType>;
+  extensionTokenPair?: Resolver<IResolversTypes['TokenPair'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IUserInviteCodeResolvers<ContextType = any, ParentType extends IResolversParentTypes['UserInviteCode'] = IResolversParentTypes['UserInviteCode']> = {
+  inviteCode?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  inviteeId?: Resolver<Maybe<IResolversTypes['ID']>, ParentType, ContextType>;
+  isUsed?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  usedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IWalletResolvers<ContextType = any, ParentType extends IResolversParentTypes['Wallet'] = IResolversParentTypes['Wallet']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  address?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  walletName?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  blockchain?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  chainId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mainWallet?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IResolvers<ContextType = any> = {
+  FollowingStatus?: IFollowingStatusResolvers<ContextType>;
+  Identity?: IIdentityResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  Profile?: IProfileResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  Social?: ISocialResolvers<ContextType>;
+  TokenPair?: ITokenPairResolvers<ContextType>;
+  TokenPairs?: ITokenPairsResolvers<ContextType>;
+  UserInviteCode?: IUserInviteCodeResolvers<ContextType>;
+  Wallet?: IWalletResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  Pattern?: IPatternDirectiveResolver<any, any, ContextType>;
+  Range?: IRangeDirectiveResolver<any, any, ContextType>;
+  Size?: ISizeDirectiveResolver<any, any, ContextType>;
+  connection?: IConnectionDirectiveResolver<any, any, ContextType>;
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IAddWalletElrondMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+}>;
+
+
+export type IAddWalletElrondMutation = Pick<IMutation, 'addWalletElrond'>;
+
+export type IAddWalletFlowMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+}>;
+
+
+export type IAddWalletFlowMutation = Pick<IMutation, 'addWalletFlow'>;
+
+export type IAddWalletMetamaskMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+}>;
+
+
+export type IAddWalletMetamaskMutation = Pick<IMutation, 'addWalletMetamask'>;
+
+export type IAddWalletSolanaMutationVariables = Exact<{
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+}>;
+
+
+export type IAddWalletSolanaMutation = Pick<IMutation, 'addWalletSolana'>;
+
+export type IAddWalletTezosMutationVariables = Exact<{
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+}>;
+
+
+export type IAddWalletTezosMutation = Pick<IMutation, 'addWalletTezos'>;
+
+export type ICreateNonceMutationVariables = Exact<{
+  address: Scalars['String'];
+  blockchain: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type ICreateNonceMutation = Pick<IMutation, 'createNonce'>;
+
+export type IGenerateNewInviteCodesMutationVariables = Exact<{
+  codesNum: Scalars['Int'];
+}>;
+
+
+export type IGenerateNewInviteCodesMutation = { generateNewInviteCodes: Array<Pick<IUserInviteCode, 'inviteCode' | 'inviteeId' | 'isUsed' | 'usedAt'>> };
+
+export type IUseInviteCodeMutationVariables = Exact<{
+  inviteCode: Scalars['String'];
+}>;
+
+
+export type IUseInviteCodeMutation = Pick<IMutation, 'useInviteCode'>;
+
+export type IRemoveWalletMutationVariables = Exact<{
+  blockchain: Scalars['String'];
+  address: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type IRemoveWalletMutation = Pick<IMutation, 'removeWallet'>;
+
+export type ISaveEmailOfJoinerMutationVariables = Exact<{
+  email: Scalars['String'];
+  isSubscribed: Scalars['Boolean'];
+}>;
+
+
+export type ISaveEmailOfJoinerMutation = Pick<IMutation, 'saveEmailOfJoiner'>;
+
+export type ISetMainWalletMutationVariables = Exact<{
+  blockchain: Scalars['String'];
+  address: Scalars['String'];
+  chainId?: Maybe<Scalars['String']>;
+}>;
+
+
+export type ISetMainWalletMutation = Pick<IMutation, 'setMainWallet'>;
+
+export type ISignInAdminMetamaskMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+}>;
+
+
+export type ISignInAdminMetamaskMutation = { signInAdminMetamask: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type ISignInElrondMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+}>;
+
+
+export type ISignInElrondMutation = { signInElrond: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type ISignInFlowMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+}>;
+
+
+export type ISignInFlowMutation = { signInFlow: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type ISignInMetamaskMutationVariables = Exact<{
+  signature: Scalars['String'];
+  address: Scalars['String'];
+  chainId: Scalars['String'];
+}>;
+
+
+export type ISignInMetamaskMutation = { signInMetamask: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type ISignInSolanaMutationVariables = Exact<{
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+}>;
+
+
+export type ISignInSolanaMutation = { signInSolana: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type ISignInTezosMutationVariables = Exact<{
+  signature: Scalars['String'];
+  pubkey: Scalars['String'];
+}>;
+
+
+export type ISignInTezosMutation = { signInTezos: (
+    Pick<IIdentity, 'userId' | 'wallets' | 'newUser' | 'inviteCode' | 'role'>
+    & { tokens: { portalTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'>, extensionTokenPair: Pick<ITokenPair, 'authToken' | 'refreshToken'> } }
+  ) };
+
+export type IUpdateProfileMutationVariables = Exact<{
+  username?: Maybe<Scalars['String']>;
+  about?: Maybe<Scalars['String']>;
+  facebook?: Maybe<Scalars['String']>;
+  twitter?: Maybe<Scalars['String']>;
+  instagram?: Maybe<Scalars['String']>;
+  website?: Maybe<Scalars['String']>;
+  showNsfw?: Maybe<Scalars['Boolean']>;
+}>;
+
+
+export type IUpdateProfileMutation = Pick<IMutation, 'updateProfile'>;
+
+export type IFetchProfileQueryVariables = Exact<{
+  userId: Scalars['ID'];
+}>;
+
+
+export type IFetchProfileQuery = { fetchProfile: (
+    Pick<IProfile, 'userId' | 'username' | 'about' | 'userpic' | 'following' | 'followings' | 'followers' | 'rank' | 'views' | 'createdAt' | 'deletedAt' | 'visible' | 'deleted' | 'showNsfw'>
+    & { social?: Maybe<Pick<ISocial, 'facebook' | 'twitter' | 'instagram' | 'website'>>, wallets?: Maybe<Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId'>>>> }
+  ) };
+
+export type IFetchUserWalletsQueryVariables = Exact<{
+  userId: Scalars['ID'];
+}>;
+
+
+export type IFetchUserWalletsQuery = { fetchUserWallets: Array<Maybe<Pick<IWallet, 'userId' | 'address' | 'walletName' | 'blockchain' | 'chainId' | 'mainWallet'>>> };
+
+export type IGetMyInviteCodesQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IGetMyInviteCodesQuery = { getMyInviteCodes: Array<Pick<IUserInviteCode, 'inviteCode' | 'inviteeId' | 'isUsed' | 'usedAt'>> };
+
+
+export const AddWalletElrondDocument = gql`
+    mutation AddWalletElrond($signature: String!, $address: String!) {
+  addWalletElrond(signature: $signature, address: $address)
+}
+    `;
+export type IAddWalletElrondMutationFn = Apollo.MutationFunction<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>;
+
+/**
+ * __useAddWalletElrondMutation__
+ *
+ * To run a mutation, you first call `useAddWalletElrondMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletElrondMutation` 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 [addWalletElrondMutation, { data, loading, error }] = useAddWalletElrondMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useAddWalletElrondMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>) {
+        return Apollo.useMutation<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>(AddWalletElrondDocument, baseOptions);
+      }
+export type AddWalletElrondMutationHookResult = ReturnType<typeof useAddWalletElrondMutation>;
+export type AddWalletElrondMutationResult = Apollo.MutationResult<IAddWalletElrondMutation>;
+export type AddWalletElrondMutationOptions = Apollo.BaseMutationOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>;
+export const AddWalletFlowDocument = gql`
+    mutation AddWalletFlow($signature: String!, $address: String!) {
+  addWalletFlow(signature: $signature, address: $address)
+}
+    `;
+export type IAddWalletFlowMutationFn = Apollo.MutationFunction<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>;
+
+/**
+ * __useAddWalletFlowMutation__
+ *
+ * To run a mutation, you first call `useAddWalletFlowMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletFlowMutation` 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 [addWalletFlowMutation, { data, loading, error }] = useAddWalletFlowMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useAddWalletFlowMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>) {
+        return Apollo.useMutation<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>(AddWalletFlowDocument, baseOptions);
+      }
+export type AddWalletFlowMutationHookResult = ReturnType<typeof useAddWalletFlowMutation>;
+export type AddWalletFlowMutationResult = Apollo.MutationResult<IAddWalletFlowMutation>;
+export type AddWalletFlowMutationOptions = Apollo.BaseMutationOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>;
+export const AddWalletMetamaskDocument = gql`
+    mutation AddWalletMetamask($signature: String!, $address: String!, $chainId: String!) {
+  addWalletMetamask(signature: $signature, address: $address, chainId: $chainId)
+}
+    `;
+export type IAddWalletMetamaskMutationFn = Apollo.MutationFunction<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>;
+
+/**
+ * __useAddWalletMetamaskMutation__
+ *
+ * To run a mutation, you first call `useAddWalletMetamaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletMetamaskMutation` 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 [addWalletMetamaskMutation, { data, loading, error }] = useAddWalletMetamaskMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useAddWalletMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>) {
+        return Apollo.useMutation<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>(AddWalletMetamaskDocument, baseOptions);
+      }
+export type AddWalletMetamaskMutationHookResult = ReturnType<typeof useAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationResult = Apollo.MutationResult<IAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationOptions = Apollo.BaseMutationOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>;
+export const AddWalletSolanaDocument = gql`
+    mutation AddWalletSolana($signature: String!, $pubkey: String!) {
+  addWalletSolana(signature: $signature, pubkey: $pubkey)
+}
+    `;
+export type IAddWalletSolanaMutationFn = Apollo.MutationFunction<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>;
+
+/**
+ * __useAddWalletSolanaMutation__
+ *
+ * To run a mutation, you first call `useAddWalletSolanaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletSolanaMutation` 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 [addWalletSolanaMutation, { data, loading, error }] = useAddWalletSolanaMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export function useAddWalletSolanaMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>) {
+        return Apollo.useMutation<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>(AddWalletSolanaDocument, baseOptions);
+      }
+export type AddWalletSolanaMutationHookResult = ReturnType<typeof useAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationResult = Apollo.MutationResult<IAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationOptions = Apollo.BaseMutationOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>;
+export const AddWalletTezosDocument = gql`
+    mutation AddWalletTezos($signature: String!, $pubkey: String!) {
+  addWalletTezos(signature: $signature, pubkey: $pubkey)
+}
+    `;
+export type IAddWalletTezosMutationFn = Apollo.MutationFunction<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>;
+
+/**
+ * __useAddWalletTezosMutation__
+ *
+ * To run a mutation, you first call `useAddWalletTezosMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useAddWalletTezosMutation` 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 [addWalletTezosMutation, { data, loading, error }] = useAddWalletTezosMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export function useAddWalletTezosMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>) {
+        return Apollo.useMutation<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>(AddWalletTezosDocument, baseOptions);
+      }
+export type AddWalletTezosMutationHookResult = ReturnType<typeof useAddWalletTezosMutation>;
+export type AddWalletTezosMutationResult = Apollo.MutationResult<IAddWalletTezosMutation>;
+export type AddWalletTezosMutationOptions = Apollo.BaseMutationOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>;
+export const CreateNonceDocument = gql`
+    mutation CreateNonce($address: String!, $blockchain: String!, $chainId: String) {
+  createNonce(address: $address, blockchain: $blockchain, chainId: $chainId)
+}
+    `;
+export type ICreateNonceMutationFn = Apollo.MutationFunction<ICreateNonceMutation, ICreateNonceMutationVariables>;
+
+/**
+ * __useCreateNonceMutation__
+ *
+ * To run a mutation, you first call `useCreateNonceMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useCreateNonceMutation` 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 [createNonceMutation, { data, loading, error }] = useCreateNonceMutation({
+ *   variables: {
+ *      address: // value for 'address'
+ *      blockchain: // value for 'blockchain'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useCreateNonceMutation(baseOptions?: Apollo.MutationHookOptions<ICreateNonceMutation, ICreateNonceMutationVariables>) {
+        return Apollo.useMutation<ICreateNonceMutation, ICreateNonceMutationVariables>(CreateNonceDocument, baseOptions);
+      }
+export type CreateNonceMutationHookResult = ReturnType<typeof useCreateNonceMutation>;
+export type CreateNonceMutationResult = Apollo.MutationResult<ICreateNonceMutation>;
+export type CreateNonceMutationOptions = Apollo.BaseMutationOptions<ICreateNonceMutation, ICreateNonceMutationVariables>;
+export const GenerateNewInviteCodesDocument = gql`
+    mutation GenerateNewInviteCodes($codesNum: Int!) {
+  generateNewInviteCodes(codesNum: $codesNum) {
+    inviteCode
+    inviteeId
+    isUsed
+    usedAt
+  }
+}
+    `;
+export type IGenerateNewInviteCodesMutationFn = Apollo.MutationFunction<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>;
+
+/**
+ * __useGenerateNewInviteCodesMutation__
+ *
+ * To run a mutation, you first call `useGenerateNewInviteCodesMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useGenerateNewInviteCodesMutation` 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 [generateNewInviteCodesMutation, { data, loading, error }] = useGenerateNewInviteCodesMutation({
+ *   variables: {
+ *      codesNum: // value for 'codesNum'
+ *   },
+ * });
+ */
+export function useGenerateNewInviteCodesMutation(baseOptions?: Apollo.MutationHookOptions<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>) {
+        return Apollo.useMutation<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>(GenerateNewInviteCodesDocument, baseOptions);
+      }
+export type GenerateNewInviteCodesMutationHookResult = ReturnType<typeof useGenerateNewInviteCodesMutation>;
+export type GenerateNewInviteCodesMutationResult = Apollo.MutationResult<IGenerateNewInviteCodesMutation>;
+export type GenerateNewInviteCodesMutationOptions = Apollo.BaseMutationOptions<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>;
+export const UseInviteCodeDocument = gql`
+    mutation UseInviteCode($inviteCode: String!) {
+  useInviteCode(inviteCode: $inviteCode)
+}
+    `;
+export type IUseInviteCodeMutationFn = Apollo.MutationFunction<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>;
+
+/**
+ * __useUseInviteCodeMutation__
+ *
+ * To run a mutation, you first call `useUseInviteCodeMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUseInviteCodeMutation` 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 [useInviteCodeMutation, { data, loading, error }] = useUseInviteCodeMutation({
+ *   variables: {
+ *      inviteCode: // value for 'inviteCode'
+ *   },
+ * });
+ */
+export function useUseInviteCodeMutation(baseOptions?: Apollo.MutationHookOptions<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>) {
+        return Apollo.useMutation<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>(UseInviteCodeDocument, baseOptions);
+      }
+export type UseInviteCodeMutationHookResult = ReturnType<typeof useUseInviteCodeMutation>;
+export type UseInviteCodeMutationResult = Apollo.MutationResult<IUseInviteCodeMutation>;
+export type UseInviteCodeMutationOptions = Apollo.BaseMutationOptions<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>;
+export const RemoveWalletDocument = gql`
+    mutation RemoveWallet($blockchain: String!, $address: String!, $chainId: String) {
+  removeWallet(blockchain: $blockchain, address: $address, chainId: $chainId)
+}
+    `;
+export type IRemoveWalletMutationFn = Apollo.MutationFunction<IRemoveWalletMutation, IRemoveWalletMutationVariables>;
+
+/**
+ * __useRemoveWalletMutation__
+ *
+ * To run a mutation, you first call `useRemoveWalletMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useRemoveWalletMutation` 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 [removeWalletMutation, { data, loading, error }] = useRemoveWalletMutation({
+ *   variables: {
+ *      blockchain: // value for 'blockchain'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useRemoveWalletMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveWalletMutation, IRemoveWalletMutationVariables>) {
+        return Apollo.useMutation<IRemoveWalletMutation, IRemoveWalletMutationVariables>(RemoveWalletDocument, baseOptions);
+      }
+export type RemoveWalletMutationHookResult = ReturnType<typeof useRemoveWalletMutation>;
+export type RemoveWalletMutationResult = Apollo.MutationResult<IRemoveWalletMutation>;
+export type RemoveWalletMutationOptions = Apollo.BaseMutationOptions<IRemoveWalletMutation, IRemoveWalletMutationVariables>;
+export const SaveEmailOfJoinerDocument = gql`
+    mutation SaveEmailOfJoiner($email: String!, $isSubscribed: Boolean!) {
+  saveEmailOfJoiner(email: $email, isSubscribed: $isSubscribed)
+}
+    `;
+export type ISaveEmailOfJoinerMutationFn = Apollo.MutationFunction<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>;
+
+/**
+ * __useSaveEmailOfJoinerMutation__
+ *
+ * To run a mutation, you first call `useSaveEmailOfJoinerMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSaveEmailOfJoinerMutation` 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 [saveEmailOfJoinerMutation, { data, loading, error }] = useSaveEmailOfJoinerMutation({
+ *   variables: {
+ *      email: // value for 'email'
+ *      isSubscribed: // value for 'isSubscribed'
+ *   },
+ * });
+ */
+export function useSaveEmailOfJoinerMutation(baseOptions?: Apollo.MutationHookOptions<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>) {
+        return Apollo.useMutation<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>(SaveEmailOfJoinerDocument, baseOptions);
+      }
+export type SaveEmailOfJoinerMutationHookResult = ReturnType<typeof useSaveEmailOfJoinerMutation>;
+export type SaveEmailOfJoinerMutationResult = Apollo.MutationResult<ISaveEmailOfJoinerMutation>;
+export type SaveEmailOfJoinerMutationOptions = Apollo.BaseMutationOptions<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>;
+export const SetMainWalletDocument = gql`
+    mutation SetMainWallet($blockchain: String!, $address: String!, $chainId: String) {
+  setMainWallet(blockchain: $blockchain, address: $address, chainId: $chainId)
+}
+    `;
+export type ISetMainWalletMutationFn = Apollo.MutationFunction<ISetMainWalletMutation, ISetMainWalletMutationVariables>;
+
+/**
+ * __useSetMainWalletMutation__
+ *
+ * To run a mutation, you first call `useSetMainWalletMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSetMainWalletMutation` 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 [setMainWalletMutation, { data, loading, error }] = useSetMainWalletMutation({
+ *   variables: {
+ *      blockchain: // value for 'blockchain'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useSetMainWalletMutation(baseOptions?: Apollo.MutationHookOptions<ISetMainWalletMutation, ISetMainWalletMutationVariables>) {
+        return Apollo.useMutation<ISetMainWalletMutation, ISetMainWalletMutationVariables>(SetMainWalletDocument, baseOptions);
+      }
+export type SetMainWalletMutationHookResult = ReturnType<typeof useSetMainWalletMutation>;
+export type SetMainWalletMutationResult = Apollo.MutationResult<ISetMainWalletMutation>;
+export type SetMainWalletMutationOptions = Apollo.BaseMutationOptions<ISetMainWalletMutation, ISetMainWalletMutationVariables>;
+export const SignInAdminMetamaskDocument = gql`
+    mutation SignInAdminMetamask($signature: String!, $address: String!, $chainId: String!) {
+  signInAdminMetamask(signature: $signature, address: $address, chainId: $chainId) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInAdminMetamaskMutationFn = Apollo.MutationFunction<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>;
+
+/**
+ * __useSignInAdminMetamaskMutation__
+ *
+ * To run a mutation, you first call `useSignInAdminMetamaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInAdminMetamaskMutation` 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 [signInAdminMetamaskMutation, { data, loading, error }] = useSignInAdminMetamaskMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useSignInAdminMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>) {
+        return Apollo.useMutation<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>(SignInAdminMetamaskDocument, baseOptions);
+      }
+export type SignInAdminMetamaskMutationHookResult = ReturnType<typeof useSignInAdminMetamaskMutation>;
+export type SignInAdminMetamaskMutationResult = Apollo.MutationResult<ISignInAdminMetamaskMutation>;
+export type SignInAdminMetamaskMutationOptions = Apollo.BaseMutationOptions<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>;
+export const SignInElrondDocument = gql`
+    mutation SignInElrond($signature: String!, $address: String!) {
+  signInElrond(signature: $signature, address: $address) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInElrondMutationFn = Apollo.MutationFunction<ISignInElrondMutation, ISignInElrondMutationVariables>;
+
+/**
+ * __useSignInElrondMutation__
+ *
+ * To run a mutation, you first call `useSignInElrondMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInElrondMutation` 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 [signInElrondMutation, { data, loading, error }] = useSignInElrondMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useSignInElrondMutation(baseOptions?: Apollo.MutationHookOptions<ISignInElrondMutation, ISignInElrondMutationVariables>) {
+        return Apollo.useMutation<ISignInElrondMutation, ISignInElrondMutationVariables>(SignInElrondDocument, baseOptions);
+      }
+export type SignInElrondMutationHookResult = ReturnType<typeof useSignInElrondMutation>;
+export type SignInElrondMutationResult = Apollo.MutationResult<ISignInElrondMutation>;
+export type SignInElrondMutationOptions = Apollo.BaseMutationOptions<ISignInElrondMutation, ISignInElrondMutationVariables>;
+export const SignInFlowDocument = gql`
+    mutation SignInFlow($signature: String!, $address: String!) {
+  signInFlow(signature: $signature, address: $address) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInFlowMutationFn = Apollo.MutationFunction<ISignInFlowMutation, ISignInFlowMutationVariables>;
+
+/**
+ * __useSignInFlowMutation__
+ *
+ * To run a mutation, you first call `useSignInFlowMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInFlowMutation` 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 [signInFlowMutation, { data, loading, error }] = useSignInFlowMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *   },
+ * });
+ */
+export function useSignInFlowMutation(baseOptions?: Apollo.MutationHookOptions<ISignInFlowMutation, ISignInFlowMutationVariables>) {
+        return Apollo.useMutation<ISignInFlowMutation, ISignInFlowMutationVariables>(SignInFlowDocument, baseOptions);
+      }
+export type SignInFlowMutationHookResult = ReturnType<typeof useSignInFlowMutation>;
+export type SignInFlowMutationResult = Apollo.MutationResult<ISignInFlowMutation>;
+export type SignInFlowMutationOptions = Apollo.BaseMutationOptions<ISignInFlowMutation, ISignInFlowMutationVariables>;
+export const SignInMetamaskDocument = gql`
+    mutation SignInMetamask($signature: String!, $address: String!, $chainId: String!) {
+  signInMetamask(signature: $signature, address: $address, chainId: $chainId) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInMetamaskMutationFn = Apollo.MutationFunction<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>;
+
+/**
+ * __useSignInMetamaskMutation__
+ *
+ * To run a mutation, you first call `useSignInMetamaskMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInMetamaskMutation` 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 [signInMetamaskMutation, { data, loading, error }] = useSignInMetamaskMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      address: // value for 'address'
+ *      chainId: // value for 'chainId'
+ *   },
+ * });
+ */
+export function useSignInMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>) {
+        return Apollo.useMutation<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>(SignInMetamaskDocument, baseOptions);
+      }
+export type SignInMetamaskMutationHookResult = ReturnType<typeof useSignInMetamaskMutation>;
+export type SignInMetamaskMutationResult = Apollo.MutationResult<ISignInMetamaskMutation>;
+export type SignInMetamaskMutationOptions = Apollo.BaseMutationOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>;
+export const SignInSolanaDocument = gql`
+    mutation SignInSolana($signature: String!, $pubkey: String!) {
+  signInSolana(signature: $signature, pubkey: $pubkey) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInSolanaMutationFn = Apollo.MutationFunction<ISignInSolanaMutation, ISignInSolanaMutationVariables>;
+
+/**
+ * __useSignInSolanaMutation__
+ *
+ * To run a mutation, you first call `useSignInSolanaMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInSolanaMutation` 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 [signInSolanaMutation, { data, loading, error }] = useSignInSolanaMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export function useSignInSolanaMutation(baseOptions?: Apollo.MutationHookOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>) {
+        return Apollo.useMutation<ISignInSolanaMutation, ISignInSolanaMutationVariables>(SignInSolanaDocument, baseOptions);
+      }
+export type SignInSolanaMutationHookResult = ReturnType<typeof useSignInSolanaMutation>;
+export type SignInSolanaMutationResult = Apollo.MutationResult<ISignInSolanaMutation>;
+export type SignInSolanaMutationOptions = Apollo.BaseMutationOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>;
+export const SignInTezosDocument = gql`
+    mutation SignInTezos($signature: String!, $pubkey: String!) {
+  signInTezos(signature: $signature, pubkey: $pubkey) {
+    userId
+    wallets
+    tokens {
+      portalTokenPair {
+        authToken
+        refreshToken
+      }
+      extensionTokenPair {
+        authToken
+        refreshToken
+      }
+    }
+    newUser
+    inviteCode
+    role
+  }
+}
+    `;
+export type ISignInTezosMutationFn = Apollo.MutationFunction<ISignInTezosMutation, ISignInTezosMutationVariables>;
+
+/**
+ * __useSignInTezosMutation__
+ *
+ * To run a mutation, you first call `useSignInTezosMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useSignInTezosMutation` 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 [signInTezosMutation, { data, loading, error }] = useSignInTezosMutation({
+ *   variables: {
+ *      signature: // value for 'signature'
+ *      pubkey: // value for 'pubkey'
+ *   },
+ * });
+ */
+export function useSignInTezosMutation(baseOptions?: Apollo.MutationHookOptions<ISignInTezosMutation, ISignInTezosMutationVariables>) {
+        return Apollo.useMutation<ISignInTezosMutation, ISignInTezosMutationVariables>(SignInTezosDocument, baseOptions);
+      }
+export type SignInTezosMutationHookResult = ReturnType<typeof useSignInTezosMutation>;
+export type SignInTezosMutationResult = Apollo.MutationResult<ISignInTezosMutation>;
+export type SignInTezosMutationOptions = Apollo.BaseMutationOptions<ISignInTezosMutation, ISignInTezosMutationVariables>;
+export const UpdateProfileDocument = gql`
+    mutation UpdateProfile($username: String, $about: String, $facebook: String, $twitter: String, $instagram: String, $website: String, $showNsfw: Boolean) {
+  updateProfile(
+    profile: {username: $username, about: $about, showNsfw: $showNsfw, social: {facebook: $facebook, twitter: $twitter, instagram: $instagram, website: $website}}
+  )
+}
+    `;
+export type IUpdateProfileMutationFn = Apollo.MutationFunction<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+
+/**
+ * __useUpdateProfileMutation__
+ *
+ * To run a mutation, you first call `useUpdateProfileMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useUpdateProfileMutation` 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 [updateProfileMutation, { data, loading, error }] = useUpdateProfileMutation({
+ *   variables: {
+ *      username: // value for 'username'
+ *      about: // value for 'about'
+ *      facebook: // value for 'facebook'
+ *      twitter: // value for 'twitter'
+ *      instagram: // value for 'instagram'
+ *      website: // value for 'website'
+ *      showNsfw: // value for 'showNsfw'
+ *   },
+ * });
+ */
+export function useUpdateProfileMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>) {
+        return Apollo.useMutation<IUpdateProfileMutation, IUpdateProfileMutationVariables>(UpdateProfileDocument, baseOptions);
+      }
+export type UpdateProfileMutationHookResult = ReturnType<typeof useUpdateProfileMutation>;
+export type UpdateProfileMutationResult = Apollo.MutationResult<IUpdateProfileMutation>;
+export type UpdateProfileMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+export const FetchProfileDocument = gql`
+    query FetchProfile($userId: ID!) {
+  fetchProfile(userId: $userId) {
+    userId
+    username
+    about
+    userpic
+    following
+    followings
+    followers
+    rank
+    social {
+      facebook
+      twitter
+      instagram
+      website
+    }
+    views
+    createdAt
+    deletedAt
+    visible
+    deleted
+    showNsfw
+    wallets {
+      userId
+      address
+      walletName
+      blockchain
+      chainId
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchProfileQuery__
+ *
+ * To run a query within a React component, call `useFetchProfileQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchProfileQuery` 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 } = useFetchProfileQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export function useFetchProfileQuery(baseOptions: Apollo.QueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>) {
+        return Apollo.useQuery<IFetchProfileQuery, IFetchProfileQueryVariables>(FetchProfileDocument, baseOptions);
+      }
+export function useFetchProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchProfileQuery, IFetchProfileQueryVariables>(FetchProfileDocument, baseOptions);
+        }
+export type FetchProfileQueryHookResult = ReturnType<typeof useFetchProfileQuery>;
+export type FetchProfileLazyQueryHookResult = ReturnType<typeof useFetchProfileLazyQuery>;
+export type FetchProfileQueryResult = Apollo.QueryResult<IFetchProfileQuery, IFetchProfileQueryVariables>;
+export const FetchUserWalletsDocument = gql`
+    query FetchUserWallets($userId: ID!) {
+  fetchUserWallets(userId: $userId) {
+    userId
+    address
+    walletName
+    blockchain
+    chainId
+    mainWallet
+  }
+}
+    `;
+
+/**
+ * __useFetchUserWalletsQuery__
+ *
+ * To run a query within a React component, call `useFetchUserWalletsQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchUserWalletsQuery` 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 } = useFetchUserWalletsQuery({
+ *   variables: {
+ *      userId: // value for 'userId'
+ *   },
+ * });
+ */
+export function useFetchUserWalletsQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>) {
+        return Apollo.useQuery<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>(FetchUserWalletsDocument, baseOptions);
+      }
+export function useFetchUserWalletsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>(FetchUserWalletsDocument, baseOptions);
+        }
+export type FetchUserWalletsQueryHookResult = ReturnType<typeof useFetchUserWalletsQuery>;
+export type FetchUserWalletsLazyQueryHookResult = ReturnType<typeof useFetchUserWalletsLazyQuery>;
+export type FetchUserWalletsQueryResult = Apollo.QueryResult<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>;
+export const GetMyInviteCodesDocument = gql`
+    query GetMyInviteCodes {
+  getMyInviteCodes {
+    inviteCode
+    inviteeId
+    isUsed
+    usedAt
+  }
+}
+    `;
+
+/**
+ * __useGetMyInviteCodesQuery__
+ *
+ * To run a query within a React component, call `useGetMyInviteCodesQuery` and pass it any options that fit your needs.
+ * When your component renders, `useGetMyInviteCodesQuery` 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 } = useGetMyInviteCodesQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useGetMyInviteCodesQuery(baseOptions?: Apollo.QueryHookOptions<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>) {
+        return Apollo.useQuery<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>(GetMyInviteCodesDocument, baseOptions);
+      }
+export function useGetMyInviteCodesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>) {
+          return Apollo.useLazyQuery<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>(GetMyInviteCodesDocument, baseOptions);
+        }
+export type GetMyInviteCodesQueryHookResult = ReturnType<typeof useGetMyInviteCodesQuery>;
+export type GetMyInviteCodesLazyQueryHookResult = ReturnType<typeof useGetMyInviteCodesLazyQuery>;
+export type GetMyInviteCodesQueryResult = Apollo.QueryResult<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>;