@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,1205 @@
+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;
+};
+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 declare 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 declare const AddWalletElrondDocument: Apollo.DocumentNode;
+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 declare function useAddWalletElrondMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>): Apollo.MutationTuple<IAddWalletElrondMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletElrondMutationHookResult = ReturnType<typeof useAddWalletElrondMutation>;
+export type AddWalletElrondMutationResult = Apollo.MutationResult<IAddWalletElrondMutation>;
+export type AddWalletElrondMutationOptions = Apollo.BaseMutationOptions<IAddWalletElrondMutation, IAddWalletElrondMutationVariables>;
+export declare const AddWalletFlowDocument: Apollo.DocumentNode;
+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 declare function useAddWalletFlowMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>): Apollo.MutationTuple<IAddWalletFlowMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletFlowMutationHookResult = ReturnType<typeof useAddWalletFlowMutation>;
+export type AddWalletFlowMutationResult = Apollo.MutationResult<IAddWalletFlowMutation>;
+export type AddWalletFlowMutationOptions = Apollo.BaseMutationOptions<IAddWalletFlowMutation, IAddWalletFlowMutationVariables>;
+export declare const AddWalletMetamaskDocument: Apollo.DocumentNode;
+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 declare function useAddWalletMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>): Apollo.MutationTuple<IAddWalletMetamaskMutation, Exact<{
+    signature: string;
+    address: string;
+    chainId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletMetamaskMutationHookResult = ReturnType<typeof useAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationResult = Apollo.MutationResult<IAddWalletMetamaskMutation>;
+export type AddWalletMetamaskMutationOptions = Apollo.BaseMutationOptions<IAddWalletMetamaskMutation, IAddWalletMetamaskMutationVariables>;
+export declare const AddWalletSolanaDocument: Apollo.DocumentNode;
+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 declare function useAddWalletSolanaMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>): Apollo.MutationTuple<IAddWalletSolanaMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletSolanaMutationHookResult = ReturnType<typeof useAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationResult = Apollo.MutationResult<IAddWalletSolanaMutation>;
+export type AddWalletSolanaMutationOptions = Apollo.BaseMutationOptions<IAddWalletSolanaMutation, IAddWalletSolanaMutationVariables>;
+export declare const AddWalletTezosDocument: Apollo.DocumentNode;
+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 declare function useAddWalletTezosMutation(baseOptions?: Apollo.MutationHookOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>): Apollo.MutationTuple<IAddWalletTezosMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type AddWalletTezosMutationHookResult = ReturnType<typeof useAddWalletTezosMutation>;
+export type AddWalletTezosMutationResult = Apollo.MutationResult<IAddWalletTezosMutation>;
+export type AddWalletTezosMutationOptions = Apollo.BaseMutationOptions<IAddWalletTezosMutation, IAddWalletTezosMutationVariables>;
+export declare const CreateNonceDocument: Apollo.DocumentNode;
+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 declare function useCreateNonceMutation(baseOptions?: Apollo.MutationHookOptions<ICreateNonceMutation, ICreateNonceMutationVariables>): Apollo.MutationTuple<ICreateNonceMutation, Exact<{
+    address: string;
+    blockchain: string;
+    chainId?: Maybe<string> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type CreateNonceMutationHookResult = ReturnType<typeof useCreateNonceMutation>;
+export type CreateNonceMutationResult = Apollo.MutationResult<ICreateNonceMutation>;
+export type CreateNonceMutationOptions = Apollo.BaseMutationOptions<ICreateNonceMutation, ICreateNonceMutationVariables>;
+export declare const GenerateNewInviteCodesDocument: Apollo.DocumentNode;
+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 declare function useGenerateNewInviteCodesMutation(baseOptions?: Apollo.MutationHookOptions<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>): Apollo.MutationTuple<IGenerateNewInviteCodesMutation, Exact<{
+    codesNum: number;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type GenerateNewInviteCodesMutationHookResult = ReturnType<typeof useGenerateNewInviteCodesMutation>;
+export type GenerateNewInviteCodesMutationResult = Apollo.MutationResult<IGenerateNewInviteCodesMutation>;
+export type GenerateNewInviteCodesMutationOptions = Apollo.BaseMutationOptions<IGenerateNewInviteCodesMutation, IGenerateNewInviteCodesMutationVariables>;
+export declare const UseInviteCodeDocument: Apollo.DocumentNode;
+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 declare function useUseInviteCodeMutation(baseOptions?: Apollo.MutationHookOptions<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>): Apollo.MutationTuple<IUseInviteCodeMutation, Exact<{
+    inviteCode: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UseInviteCodeMutationHookResult = ReturnType<typeof useUseInviteCodeMutation>;
+export type UseInviteCodeMutationResult = Apollo.MutationResult<IUseInviteCodeMutation>;
+export type UseInviteCodeMutationOptions = Apollo.BaseMutationOptions<IUseInviteCodeMutation, IUseInviteCodeMutationVariables>;
+export declare const RemoveWalletDocument: Apollo.DocumentNode;
+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 declare function useRemoveWalletMutation(baseOptions?: Apollo.MutationHookOptions<IRemoveWalletMutation, IRemoveWalletMutationVariables>): Apollo.MutationTuple<IRemoveWalletMutation, Exact<{
+    blockchain: string;
+    address: string;
+    chainId?: Maybe<string> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type RemoveWalletMutationHookResult = ReturnType<typeof useRemoveWalletMutation>;
+export type RemoveWalletMutationResult = Apollo.MutationResult<IRemoveWalletMutation>;
+export type RemoveWalletMutationOptions = Apollo.BaseMutationOptions<IRemoveWalletMutation, IRemoveWalletMutationVariables>;
+export declare const SaveEmailOfJoinerDocument: Apollo.DocumentNode;
+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 declare function useSaveEmailOfJoinerMutation(baseOptions?: Apollo.MutationHookOptions<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>): Apollo.MutationTuple<ISaveEmailOfJoinerMutation, Exact<{
+    email: string;
+    isSubscribed: boolean;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SaveEmailOfJoinerMutationHookResult = ReturnType<typeof useSaveEmailOfJoinerMutation>;
+export type SaveEmailOfJoinerMutationResult = Apollo.MutationResult<ISaveEmailOfJoinerMutation>;
+export type SaveEmailOfJoinerMutationOptions = Apollo.BaseMutationOptions<ISaveEmailOfJoinerMutation, ISaveEmailOfJoinerMutationVariables>;
+export declare const SetMainWalletDocument: Apollo.DocumentNode;
+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 declare function useSetMainWalletMutation(baseOptions?: Apollo.MutationHookOptions<ISetMainWalletMutation, ISetMainWalletMutationVariables>): Apollo.MutationTuple<ISetMainWalletMutation, Exact<{
+    blockchain: string;
+    address: string;
+    chainId?: Maybe<string> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SetMainWalletMutationHookResult = ReturnType<typeof useSetMainWalletMutation>;
+export type SetMainWalletMutationResult = Apollo.MutationResult<ISetMainWalletMutation>;
+export type SetMainWalletMutationOptions = Apollo.BaseMutationOptions<ISetMainWalletMutation, ISetMainWalletMutationVariables>;
+export declare const SignInAdminMetamaskDocument: Apollo.DocumentNode;
+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 declare function useSignInAdminMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>): Apollo.MutationTuple<ISignInAdminMetamaskMutation, Exact<{
+    signature: string;
+    address: string;
+    chainId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInAdminMetamaskMutationHookResult = ReturnType<typeof useSignInAdminMetamaskMutation>;
+export type SignInAdminMetamaskMutationResult = Apollo.MutationResult<ISignInAdminMetamaskMutation>;
+export type SignInAdminMetamaskMutationOptions = Apollo.BaseMutationOptions<ISignInAdminMetamaskMutation, ISignInAdminMetamaskMutationVariables>;
+export declare const SignInElrondDocument: Apollo.DocumentNode;
+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 declare function useSignInElrondMutation(baseOptions?: Apollo.MutationHookOptions<ISignInElrondMutation, ISignInElrondMutationVariables>): Apollo.MutationTuple<ISignInElrondMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInElrondMutationHookResult = ReturnType<typeof useSignInElrondMutation>;
+export type SignInElrondMutationResult = Apollo.MutationResult<ISignInElrondMutation>;
+export type SignInElrondMutationOptions = Apollo.BaseMutationOptions<ISignInElrondMutation, ISignInElrondMutationVariables>;
+export declare const SignInFlowDocument: Apollo.DocumentNode;
+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 declare function useSignInFlowMutation(baseOptions?: Apollo.MutationHookOptions<ISignInFlowMutation, ISignInFlowMutationVariables>): Apollo.MutationTuple<ISignInFlowMutation, Exact<{
+    signature: string;
+    address: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInFlowMutationHookResult = ReturnType<typeof useSignInFlowMutation>;
+export type SignInFlowMutationResult = Apollo.MutationResult<ISignInFlowMutation>;
+export type SignInFlowMutationOptions = Apollo.BaseMutationOptions<ISignInFlowMutation, ISignInFlowMutationVariables>;
+export declare const SignInMetamaskDocument: Apollo.DocumentNode;
+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 declare function useSignInMetamaskMutation(baseOptions?: Apollo.MutationHookOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>): Apollo.MutationTuple<ISignInMetamaskMutation, Exact<{
+    signature: string;
+    address: string;
+    chainId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInMetamaskMutationHookResult = ReturnType<typeof useSignInMetamaskMutation>;
+export type SignInMetamaskMutationResult = Apollo.MutationResult<ISignInMetamaskMutation>;
+export type SignInMetamaskMutationOptions = Apollo.BaseMutationOptions<ISignInMetamaskMutation, ISignInMetamaskMutationVariables>;
+export declare const SignInSolanaDocument: Apollo.DocumentNode;
+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 declare function useSignInSolanaMutation(baseOptions?: Apollo.MutationHookOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>): Apollo.MutationTuple<ISignInSolanaMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInSolanaMutationHookResult = ReturnType<typeof useSignInSolanaMutation>;
+export type SignInSolanaMutationResult = Apollo.MutationResult<ISignInSolanaMutation>;
+export type SignInSolanaMutationOptions = Apollo.BaseMutationOptions<ISignInSolanaMutation, ISignInSolanaMutationVariables>;
+export declare const SignInTezosDocument: Apollo.DocumentNode;
+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 declare function useSignInTezosMutation(baseOptions?: Apollo.MutationHookOptions<ISignInTezosMutation, ISignInTezosMutationVariables>): Apollo.MutationTuple<ISignInTezosMutation, Exact<{
+    signature: string;
+    pubkey: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type SignInTezosMutationHookResult = ReturnType<typeof useSignInTezosMutation>;
+export type SignInTezosMutationResult = Apollo.MutationResult<ISignInTezosMutation>;
+export type SignInTezosMutationOptions = Apollo.BaseMutationOptions<ISignInTezosMutation, ISignInTezosMutationVariables>;
+export declare const UpdateProfileDocument: Apollo.DocumentNode;
+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 declare function useUpdateProfileMutation(baseOptions?: Apollo.MutationHookOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>): Apollo.MutationTuple<IUpdateProfileMutation, Exact<{
+    username?: Maybe<string> | undefined;
+    about?: Maybe<string> | undefined;
+    facebook?: Maybe<string> | undefined;
+    twitter?: Maybe<string> | undefined;
+    instagram?: Maybe<string> | undefined;
+    website?: Maybe<string> | undefined;
+    showNsfw?: Maybe<boolean> | undefined;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type UpdateProfileMutationHookResult = ReturnType<typeof useUpdateProfileMutation>;
+export type UpdateProfileMutationResult = Apollo.MutationResult<IUpdateProfileMutation>;
+export type UpdateProfileMutationOptions = Apollo.BaseMutationOptions<IUpdateProfileMutation, IUpdateProfileMutationVariables>;
+export declare const FetchProfileDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchProfileQuery(baseOptions: Apollo.QueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>): Apollo.QueryResult<IFetchProfileQuery, Exact<{
+    userId: string;
+}>>;
+export declare function useFetchProfileLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchProfileQuery, IFetchProfileQueryVariables>): Apollo.LazyQueryResultTuple<IFetchProfileQuery, Exact<{
+    userId: string;
+}>>;
+export type FetchProfileQueryHookResult = ReturnType<typeof useFetchProfileQuery>;
+export type FetchProfileLazyQueryHookResult = ReturnType<typeof useFetchProfileLazyQuery>;
+export type FetchProfileQueryResult = Apollo.QueryResult<IFetchProfileQuery, IFetchProfileQueryVariables>;
+export declare const FetchUserWalletsDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchUserWalletsQuery(baseOptions: Apollo.QueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>): Apollo.QueryResult<IFetchUserWalletsQuery, Exact<{
+    userId: string;
+}>>;
+export declare function useFetchUserWalletsLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>): Apollo.LazyQueryResultTuple<IFetchUserWalletsQuery, Exact<{
+    userId: string;
+}>>;
+export type FetchUserWalletsQueryHookResult = ReturnType<typeof useFetchUserWalletsQuery>;
+export type FetchUserWalletsLazyQueryHookResult = ReturnType<typeof useFetchUserWalletsLazyQuery>;
+export type FetchUserWalletsQueryResult = Apollo.QueryResult<IFetchUserWalletsQuery, IFetchUserWalletsQueryVariables>;
+export declare const GetMyInviteCodesDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useGetMyInviteCodesQuery(baseOptions?: Apollo.QueryHookOptions<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>): Apollo.QueryResult<IGetMyInviteCodesQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useGetMyInviteCodesLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>): Apollo.LazyQueryResultTuple<IGetMyInviteCodesQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type GetMyInviteCodesQueryHookResult = ReturnType<typeof useGetMyInviteCodesQuery>;
+export type GetMyInviteCodesLazyQueryHookResult = ReturnType<typeof useGetMyInviteCodesLazyQuery>;
+export type GetMyInviteCodesQueryResult = Apollo.QueryResult<IGetMyInviteCodesQuery, IGetMyInviteCodesQueryVariables>;