@ludo.ninja/api 2.8.71 → 2.8.73

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

@@ -0,0 +1,698 @@
+/* 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 IActiveInviteCode = {
+  code: Scalars['String'];
+  usedTimes: Scalars['Int'];
+  maxUsagesLimit: Scalars['Int'];
+};
+
+export type IFarmingTask = {
+  taskId: Scalars['ID'];
+  status: Scalars['String'];
+  startedAt: Scalars['Long'];
+};
+
+export type IFrensData = {
+  activeInviteCodes: Array<IActiveInviteCode>;
+  joinedFriends: Array<IFriend>;
+};
+
+export type IFriend = {
+  userId: Scalars['ID'];
+  ludoUsername?: Maybe<Scalars['String']>;
+  isAPlayer: Scalars['Boolean'];
+  coins?: Maybe<Scalars['Int']>;
+};
+
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  startFarming: Scalars['Boolean'];
+  claimFarmingReward: Scalars['Boolean'];
+  confirmStreakNotificationHasBeenRead: Scalars['Boolean'];
+  markNotificationAsShown: Scalars['Boolean'];
+  markNotificationAsRead: Scalars['Boolean'];
+  markNotificationAsNew: Scalars['Boolean'];
+};
+
+
+export type IMutationConfirmStreakNotificationHasBeenReadArgs = {
+  streakId: Scalars['ID'];
+};
+
+
+export type IMutationMarkNotificationAsShownArgs = {
+  notificationId: Scalars['ID'];
+};
+
+
+export type IMutationMarkNotificationAsReadArgs = {
+  notificationId: Scalars['ID'];
+};
+
+
+export type IMutationMarkNotificationAsNewArgs = {
+  notificationId: Scalars['ID'];
+};
+
+export type INotification = {
+  notificationId: Scalars['ID'];
+  status: Scalars['String'];
+  text: Scalars['String'];
+  createdAt: Scalars['Long'];
+};
+
+export type IPlayerState = {
+  userId: Scalars['ID'];
+  coins: Scalars['Int'];
+  farmingTask?: Maybe<IFarmingTask>;
+  playingStreaks: Array<IPlayingStreak>;
+  notifications: Array<INotification>;
+};
+
+export type IPlayingStreak = {
+  streakId: Scalars['ID'];
+  status: Scalars['String'];
+  type: Scalars['String'];
+  startedAt: Scalars['Long'];
+};
+
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchPlayerState: IPlayerState;
+  fetchFrensData: IFrensData;
+};
+
+export type ISubscription = {
+  onDummy: Scalars['String'];
+  onPlayerStateUpdated: IPlayerState;
+};
+
+
+export type ISubscriptionOnPlayerStateUpdatedArgs = {
+  authToken: Scalars['String'];
+};
+
+
+
+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 = {
+  ActiveInviteCode: ResolverTypeWrapper<IActiveInviteCode>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  FarmingTask: ResolverTypeWrapper<IFarmingTask>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  FrensData: ResolverTypeWrapper<IFrensData>;
+  Friend: ResolverTypeWrapper<IFriend>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Notification: ResolverTypeWrapper<INotification>;
+  PlayerState: ResolverTypeWrapper<IPlayerState>;
+  PlayingStreak: ResolverTypeWrapper<IPlayingStreak>;
+  Query: ResolverTypeWrapper<{}>;
+  Subscription: ResolverTypeWrapper<{}>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  ActiveInviteCode: IActiveInviteCode;
+  String: Scalars['String'];
+  Int: Scalars['Int'];
+  FarmingTask: IFarmingTask;
+  ID: Scalars['ID'];
+  FrensData: IFrensData;
+  Friend: IFriend;
+  Boolean: Scalars['Boolean'];
+  Long: Scalars['Long'];
+  Mutation: {};
+  Notification: INotification;
+  PlayerState: IPlayerState;
+  PlayingStreak: IPlayingStreak;
+  Query: {};
+  Subscription: {};
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IActiveInviteCodeResolvers<ContextType = any, ParentType extends IResolversParentTypes['ActiveInviteCode'] = IResolversParentTypes['ActiveInviteCode']> = {
+  code?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  usedTimes?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  maxUsagesLimit?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IFarmingTaskResolvers<ContextType = any, ParentType extends IResolversParentTypes['FarmingTask'] = IResolversParentTypes['FarmingTask']> = {
+  taskId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  status?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  startedAt?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IFrensDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['FrensData'] = IResolversParentTypes['FrensData']> = {
+  activeInviteCodes?: Resolver<Array<IResolversTypes['ActiveInviteCode']>, ParentType, ContextType>;
+  joinedFriends?: Resolver<Array<IResolversTypes['Friend']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IFriendResolvers<ContextType = any, ParentType extends IResolversParentTypes['Friend'] = IResolversParentTypes['Friend']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  ludoUsername?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  isAPlayer?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  coins?: Resolver<Maybe<IResolversTypes['Int']>, 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>;
+  startFarming?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  claimFarmingReward?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType>;
+  confirmStreakNotificationHasBeenRead?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationConfirmStreakNotificationHasBeenReadArgs, 'streakId'>>;
+  markNotificationAsShown?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationMarkNotificationAsShownArgs, 'notificationId'>>;
+  markNotificationAsRead?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationMarkNotificationAsReadArgs, 'notificationId'>>;
+  markNotificationAsNew?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationMarkNotificationAsNewArgs, 'notificationId'>>;
+};
+
+export type INotificationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Notification'] = IResolversParentTypes['Notification']> = {
+  notificationId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  status?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  text?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  createdAt?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IPlayerStateResolvers<ContextType = any, ParentType extends IResolversParentTypes['PlayerState'] = IResolversParentTypes['PlayerState']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  coins?: Resolver<IResolversTypes['Int'], ParentType, ContextType>;
+  farmingTask?: Resolver<Maybe<IResolversTypes['FarmingTask']>, ParentType, ContextType>;
+  playingStreaks?: Resolver<Array<IResolversTypes['PlayingStreak']>, ParentType, ContextType>;
+  notifications?: Resolver<Array<IResolversTypes['Notification']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IPlayingStreakResolvers<ContextType = any, ParentType extends IResolversParentTypes['PlayingStreak'] = IResolversParentTypes['PlayingStreak']> = {
+  streakId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  status?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  type?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  startedAt?: Resolver<IResolversTypes['Long'], ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchPlayerState?: Resolver<IResolversTypes['PlayerState'], ParentType, ContextType>;
+  fetchFrensData?: Resolver<IResolversTypes['FrensData'], ParentType, ContextType>;
+};
+
+export type ISubscriptionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
+  onDummy?: SubscriptionResolver<IResolversTypes['String'], "onDummy", ParentType, ContextType>;
+  onPlayerStateUpdated?: SubscriptionResolver<IResolversTypes['PlayerState'], "onPlayerStateUpdated", ParentType, ContextType, RequireFields<ISubscriptionOnPlayerStateUpdatedArgs, 'authToken'>>;
+};
+
+export type IResolvers<ContextType = any> = {
+  ActiveInviteCode?: IActiveInviteCodeResolvers<ContextType>;
+  FarmingTask?: IFarmingTaskResolvers<ContextType>;
+  FrensData?: IFrensDataResolvers<ContextType>;
+  Friend?: IFriendResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Mutation?: IMutationResolvers<ContextType>;
+  Notification?: INotificationResolvers<ContextType>;
+  PlayerState?: IPlayerStateResolvers<ContextType>;
+  PlayingStreak?: IPlayingStreakResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+  Subscription?: ISubscriptionResolvers<ContextType>;
+};
+
+export type IDirectiveResolvers<ContextType = any> = {
+  oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
+};
+
+export type IClaimFarmingRewardMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IClaimFarmingRewardMutation = Pick<IMutation, 'claimFarmingReward'>;
+
+export type IConfirmStreakNotificationHasBeenReadMutationVariables = Exact<{
+  streakId: Scalars['ID'];
+}>;
+
+
+export type IConfirmStreakNotificationHasBeenReadMutation = Pick<IMutation, 'confirmStreakNotificationHasBeenRead'>;
+
+export type IMarkNotificationAsNewMutationVariables = Exact<{
+  notificationId: Scalars['ID'];
+}>;
+
+
+export type IMarkNotificationAsNewMutation = Pick<IMutation, 'markNotificationAsNew'>;
+
+export type IMarkNotificationAsReadMutationVariables = Exact<{
+  notificationId: Scalars['ID'];
+}>;
+
+
+export type IMarkNotificationAsReadMutation = Pick<IMutation, 'markNotificationAsRead'>;
+
+export type IMarkNotificationAsShownMutationVariables = Exact<{
+  notificationId: Scalars['ID'];
+}>;
+
+
+export type IMarkNotificationAsShownMutation = Pick<IMutation, 'markNotificationAsShown'>;
+
+export type IStartFarmingMutationVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IStartFarmingMutation = Pick<IMutation, 'startFarming'>;
+
+export type IFetchFrensDataQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchFrensDataQuery = { fetchFrensData: { activeInviteCodes: Array<Pick<IActiveInviteCode, 'code' | 'usedTimes' | 'maxUsagesLimit'>>, joinedFriends: Array<Pick<IFriend, 'userId' | 'ludoUsername' | 'isAPlayer' | 'coins'>> } };
+
+export type IFetchPlayerStateQueryVariables = Exact<{ [key: string]: never; }>;
+
+
+export type IFetchPlayerStateQuery = { fetchPlayerState: (
+    Pick<IPlayerState, 'userId' | 'coins'>
+    & { farmingTask?: Maybe<Pick<IFarmingTask, 'taskId' | 'status' | 'startedAt'>>, playingStreaks: Array<Pick<IPlayingStreak, 'streakId' | 'status' | 'type' | 'startedAt'>>, notifications: Array<Pick<INotification, 'notificationId' | 'status' | 'text' | 'createdAt'>> }
+  ) };
+
+export type IOnPlayerStateUpdatedSubscriptionVariables = Exact<{
+  authToken: Scalars['String'];
+}>;
+
+
+export type IOnPlayerStateUpdatedSubscription = { onPlayerStateUpdated: (
+    Pick<IPlayerState, 'userId' | 'coins'>
+    & { farmingTask?: Maybe<Pick<IFarmingTask, 'taskId' | 'status' | 'startedAt'>>, playingStreaks: Array<Pick<IPlayingStreak, 'streakId' | 'status' | 'type' | 'startedAt'>>, notifications: Array<Pick<INotification, 'notificationId' | 'status' | 'text' | 'createdAt'>> }
+  ) };
+
+
+export const ClaimFarmingRewardDocument = gql`
+    mutation ClaimFarmingReward {
+  claimFarmingReward
+}
+    `;
+export type IClaimFarmingRewardMutationFn = Apollo.MutationFunction<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>;
+
+/**
+ * __useClaimFarmingRewardMutation__
+ *
+ * To run a mutation, you first call `useClaimFarmingRewardMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useClaimFarmingRewardMutation` 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 [claimFarmingRewardMutation, { data, loading, error }] = useClaimFarmingRewardMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useClaimFarmingRewardMutation(baseOptions?: Apollo.MutationHookOptions<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>) {
+        return Apollo.useMutation<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>(ClaimFarmingRewardDocument, baseOptions);
+      }
+export type ClaimFarmingRewardMutationHookResult = ReturnType<typeof useClaimFarmingRewardMutation>;
+export type ClaimFarmingRewardMutationResult = Apollo.MutationResult<IClaimFarmingRewardMutation>;
+export type ClaimFarmingRewardMutationOptions = Apollo.BaseMutationOptions<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>;
+export const ConfirmStreakNotificationHasBeenReadDocument = gql`
+    mutation ConfirmStreakNotificationHasBeenRead($streakId: ID!) {
+  confirmStreakNotificationHasBeenRead(streakId: $streakId)
+}
+    `;
+export type IConfirmStreakNotificationHasBeenReadMutationFn = Apollo.MutationFunction<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>;
+
+/**
+ * __useConfirmStreakNotificationHasBeenReadMutation__
+ *
+ * To run a mutation, you first call `useConfirmStreakNotificationHasBeenReadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useConfirmStreakNotificationHasBeenReadMutation` 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 [confirmStreakNotificationHasBeenReadMutation, { data, loading, error }] = useConfirmStreakNotificationHasBeenReadMutation({
+ *   variables: {
+ *      streakId: // value for 'streakId'
+ *   },
+ * });
+ */
+export function useConfirmStreakNotificationHasBeenReadMutation(baseOptions?: Apollo.MutationHookOptions<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>) {
+        return Apollo.useMutation<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>(ConfirmStreakNotificationHasBeenReadDocument, baseOptions);
+      }
+export type ConfirmStreakNotificationHasBeenReadMutationHookResult = ReturnType<typeof useConfirmStreakNotificationHasBeenReadMutation>;
+export type ConfirmStreakNotificationHasBeenReadMutationResult = Apollo.MutationResult<IConfirmStreakNotificationHasBeenReadMutation>;
+export type ConfirmStreakNotificationHasBeenReadMutationOptions = Apollo.BaseMutationOptions<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>;
+export const MarkNotificationAsNewDocument = gql`
+    mutation MarkNotificationAsNew($notificationId: ID!) {
+  markNotificationAsNew(notificationId: $notificationId)
+}
+    `;
+export type IMarkNotificationAsNewMutationFn = Apollo.MutationFunction<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>;
+
+/**
+ * __useMarkNotificationAsNewMutation__
+ *
+ * To run a mutation, you first call `useMarkNotificationAsNewMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkNotificationAsNewMutation` 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 [markNotificationAsNewMutation, { data, loading, error }] = useMarkNotificationAsNewMutation({
+ *   variables: {
+ *      notificationId: // value for 'notificationId'
+ *   },
+ * });
+ */
+export function useMarkNotificationAsNewMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>) {
+        return Apollo.useMutation<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>(MarkNotificationAsNewDocument, baseOptions);
+      }
+export type MarkNotificationAsNewMutationHookResult = ReturnType<typeof useMarkNotificationAsNewMutation>;
+export type MarkNotificationAsNewMutationResult = Apollo.MutationResult<IMarkNotificationAsNewMutation>;
+export type MarkNotificationAsNewMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>;
+export const MarkNotificationAsReadDocument = gql`
+    mutation MarkNotificationAsRead($notificationId: ID!) {
+  markNotificationAsRead(notificationId: $notificationId)
+}
+    `;
+export type IMarkNotificationAsReadMutationFn = Apollo.MutationFunction<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>;
+
+/**
+ * __useMarkNotificationAsReadMutation__
+ *
+ * To run a mutation, you first call `useMarkNotificationAsReadMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkNotificationAsReadMutation` 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 [markNotificationAsReadMutation, { data, loading, error }] = useMarkNotificationAsReadMutation({
+ *   variables: {
+ *      notificationId: // value for 'notificationId'
+ *   },
+ * });
+ */
+export function useMarkNotificationAsReadMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>) {
+        return Apollo.useMutation<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>(MarkNotificationAsReadDocument, baseOptions);
+      }
+export type MarkNotificationAsReadMutationHookResult = ReturnType<typeof useMarkNotificationAsReadMutation>;
+export type MarkNotificationAsReadMutationResult = Apollo.MutationResult<IMarkNotificationAsReadMutation>;
+export type MarkNotificationAsReadMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>;
+export const MarkNotificationAsShownDocument = gql`
+    mutation MarkNotificationAsShown($notificationId: ID!) {
+  markNotificationAsShown(notificationId: $notificationId)
+}
+    `;
+export type IMarkNotificationAsShownMutationFn = Apollo.MutationFunction<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>;
+
+/**
+ * __useMarkNotificationAsShownMutation__
+ *
+ * To run a mutation, you first call `useMarkNotificationAsShownMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useMarkNotificationAsShownMutation` 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 [markNotificationAsShownMutation, { data, loading, error }] = useMarkNotificationAsShownMutation({
+ *   variables: {
+ *      notificationId: // value for 'notificationId'
+ *   },
+ * });
+ */
+export function useMarkNotificationAsShownMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>) {
+        return Apollo.useMutation<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>(MarkNotificationAsShownDocument, baseOptions);
+      }
+export type MarkNotificationAsShownMutationHookResult = ReturnType<typeof useMarkNotificationAsShownMutation>;
+export type MarkNotificationAsShownMutationResult = Apollo.MutationResult<IMarkNotificationAsShownMutation>;
+export type MarkNotificationAsShownMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>;
+export const StartFarmingDocument = gql`
+    mutation StartFarming {
+  startFarming
+}
+    `;
+export type IStartFarmingMutationFn = Apollo.MutationFunction<IStartFarmingMutation, IStartFarmingMutationVariables>;
+
+/**
+ * __useStartFarmingMutation__
+ *
+ * To run a mutation, you first call `useStartFarmingMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useStartFarmingMutation` 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 [startFarmingMutation, { data, loading, error }] = useStartFarmingMutation({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useStartFarmingMutation(baseOptions?: Apollo.MutationHookOptions<IStartFarmingMutation, IStartFarmingMutationVariables>) {
+        return Apollo.useMutation<IStartFarmingMutation, IStartFarmingMutationVariables>(StartFarmingDocument, baseOptions);
+      }
+export type StartFarmingMutationHookResult = ReturnType<typeof useStartFarmingMutation>;
+export type StartFarmingMutationResult = Apollo.MutationResult<IStartFarmingMutation>;
+export type StartFarmingMutationOptions = Apollo.BaseMutationOptions<IStartFarmingMutation, IStartFarmingMutationVariables>;
+export const FetchFrensDataDocument = gql`
+    query FetchFrensData {
+  fetchFrensData {
+    activeInviteCodes {
+      code
+      usedTimes
+      maxUsagesLimit
+    }
+    joinedFriends {
+      userId
+      ludoUsername
+      isAPlayer
+      coins
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchFrensDataQuery__
+ *
+ * To run a query within a React component, call `useFetchFrensDataQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchFrensDataQuery` 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 } = useFetchFrensDataQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchFrensDataQuery(baseOptions?: Apollo.QueryHookOptions<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>) {
+        return Apollo.useQuery<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>(FetchFrensDataDocument, baseOptions);
+      }
+export function useFetchFrensDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>(FetchFrensDataDocument, baseOptions);
+        }
+export type FetchFrensDataQueryHookResult = ReturnType<typeof useFetchFrensDataQuery>;
+export type FetchFrensDataLazyQueryHookResult = ReturnType<typeof useFetchFrensDataLazyQuery>;
+export type FetchFrensDataQueryResult = Apollo.QueryResult<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>;
+export const FetchPlayerStateDocument = gql`
+    query FetchPlayerState {
+  fetchPlayerState {
+    userId
+    coins
+    farmingTask {
+      taskId
+      status
+      startedAt
+    }
+    playingStreaks {
+      streakId
+      status
+      type
+      startedAt
+    }
+    notifications {
+      notificationId
+      status
+      text
+      createdAt
+    }
+  }
+}
+    `;
+
+/**
+ * __useFetchPlayerStateQuery__
+ *
+ * To run a query within a React component, call `useFetchPlayerStateQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchPlayerStateQuery` 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 } = useFetchPlayerStateQuery({
+ *   variables: {
+ *   },
+ * });
+ */
+export function useFetchPlayerStateQuery(baseOptions?: Apollo.QueryHookOptions<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>) {
+        return Apollo.useQuery<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>(FetchPlayerStateDocument, baseOptions);
+      }
+export function useFetchPlayerStateLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>(FetchPlayerStateDocument, baseOptions);
+        }
+export type FetchPlayerStateQueryHookResult = ReturnType<typeof useFetchPlayerStateQuery>;
+export type FetchPlayerStateLazyQueryHookResult = ReturnType<typeof useFetchPlayerStateLazyQuery>;
+export type FetchPlayerStateQueryResult = Apollo.QueryResult<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>;
+export const OnPlayerStateUpdatedDocument = gql`
+    subscription OnPlayerStateUpdated($authToken: String!) {
+  onPlayerStateUpdated(authToken: $authToken) {
+    userId
+    coins
+    farmingTask {
+      taskId
+      status
+      startedAt
+    }
+    playingStreaks {
+      streakId
+      status
+      type
+      startedAt
+    }
+    notifications {
+      notificationId
+      status
+      text
+      createdAt
+    }
+  }
+}
+    `;
+
+/**
+ * __useOnPlayerStateUpdatedSubscription__
+ *
+ * To run a query within a React component, call `useOnPlayerStateUpdatedSubscription` and pass it any options that fit your needs.
+ * When your component renders, `useOnPlayerStateUpdatedSubscription` 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 subscription, supported options are listed on: https://www.apollographql.com/docs/react/api/react-hooks/#options;
+ *
+ * @example
+ * const { data, loading, error } = useOnPlayerStateUpdatedSubscription({
+ *   variables: {
+ *      authToken: // value for 'authToken'
+ *   },
+ * });
+ */
+export function useOnPlayerStateUpdatedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnPlayerStateUpdatedSubscription, IOnPlayerStateUpdatedSubscriptionVariables>) {
+        return Apollo.useSubscription<IOnPlayerStateUpdatedSubscription, IOnPlayerStateUpdatedSubscriptionVariables>(OnPlayerStateUpdatedDocument, baseOptions);
+      }
+export type OnPlayerStateUpdatedSubscriptionHookResult = ReturnType<typeof useOnPlayerStateUpdatedSubscription>;
+export type OnPlayerStateUpdatedSubscriptionResult = Apollo.SubscriptionResult<IOnPlayerStateUpdatedSubscription>;