@ludo.ninja/api 2.8.72 → 2.8.73

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

@@ -368,6 +368,7 @@ export type IMutation = {
     triggerOpportunityNotification: Scalars['Boolean'];
     updateTier: Scalars['Boolean'];
     createTier: Scalars['Boolean'];
+    updateTierArchivedStatus: Scalars['Boolean'];
     updateProfileStatus: Scalars['Boolean'];
     removeSuggestedOpportunity: Scalars['Boolean'];
     addSuggestedOpportunity: Scalars['Boolean'];
@@ -432,6 +433,10 @@ export type IMutationUpdateTierArgs = {
 export type IMutationCreateTierArgs = {
     input: ITierInput;
 };
+export type IMutationUpdateTierArchivedStatusArgs = {
+    id: Scalars['ID'];
+    isArchived: Scalars['Boolean'];
+};
 export type IMutationUpdateProfileStatusArgs = {
     userId: Scalars['ID'];
     isActive: Scalars['Boolean'];
@@ -657,6 +662,7 @@ export type ITier = {
     name: Scalars['String'];
     description?: Maybe<Scalars['String']>;
     fee?: Maybe<Scalars['Float']>;
+    archived?: Maybe<Scalars['Boolean']>;
 };
 export type ITierInput = {
     name: Scalars['String'];
@@ -1195,6 +1201,7 @@ export type IMutationResolvers<ContextType = any, ParentType extends IResolversP
     triggerOpportunityNotification?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationTriggerOpportunityNotificationArgs, 'opportunityId'>>;
     updateTier?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateTierArgs, 'id' | 'input'>>;
     createTier?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationCreateTierArgs, 'input'>>;
+    updateTierArchivedStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateTierArchivedStatusArgs, 'id' | 'isArchived'>>;
     updateProfileStatus?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationUpdateProfileStatusArgs, 'userId' | 'isActive'>>;
     removeSuggestedOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationRemoveSuggestedOpportunityArgs, 'userId' | 'opportunityId'>>;
     addSuggestedOpportunity?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationAddSuggestedOpportunityArgs, 'userId' | 'opportunityId'>>;
@@ -1261,6 +1268,7 @@ export type ITierResolvers<ContextType = any, ParentType extends IResolversParen
     name?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
     description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
     fee?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+    archived?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
     __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
 };
 export type ITiersPageResolvers<ContextType = any, ParentType extends IResolversParentTypes['TiersPage'] = IResolversParentTypes['TiersPage']> = {

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

@@ -0,0 +1,525 @@
+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 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 declare const ClaimFarmingRewardDocument: Apollo.DocumentNode;
+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 declare function useClaimFarmingRewardMutation(baseOptions?: Apollo.MutationHookOptions<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>): Apollo.MutationTuple<IClaimFarmingRewardMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ClaimFarmingRewardMutationHookResult = ReturnType<typeof useClaimFarmingRewardMutation>;
+export type ClaimFarmingRewardMutationResult = Apollo.MutationResult<IClaimFarmingRewardMutation>;
+export type ClaimFarmingRewardMutationOptions = Apollo.BaseMutationOptions<IClaimFarmingRewardMutation, IClaimFarmingRewardMutationVariables>;
+export declare const ConfirmStreakNotificationHasBeenReadDocument: Apollo.DocumentNode;
+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 declare function useConfirmStreakNotificationHasBeenReadMutation(baseOptions?: Apollo.MutationHookOptions<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>): Apollo.MutationTuple<IConfirmStreakNotificationHasBeenReadMutation, Exact<{
+    streakId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type ConfirmStreakNotificationHasBeenReadMutationHookResult = ReturnType<typeof useConfirmStreakNotificationHasBeenReadMutation>;
+export type ConfirmStreakNotificationHasBeenReadMutationResult = Apollo.MutationResult<IConfirmStreakNotificationHasBeenReadMutation>;
+export type ConfirmStreakNotificationHasBeenReadMutationOptions = Apollo.BaseMutationOptions<IConfirmStreakNotificationHasBeenReadMutation, IConfirmStreakNotificationHasBeenReadMutationVariables>;
+export declare const MarkNotificationAsNewDocument: Apollo.DocumentNode;
+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 declare function useMarkNotificationAsNewMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>): Apollo.MutationTuple<IMarkNotificationAsNewMutation, Exact<{
+    notificationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type MarkNotificationAsNewMutationHookResult = ReturnType<typeof useMarkNotificationAsNewMutation>;
+export type MarkNotificationAsNewMutationResult = Apollo.MutationResult<IMarkNotificationAsNewMutation>;
+export type MarkNotificationAsNewMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsNewMutation, IMarkNotificationAsNewMutationVariables>;
+export declare const MarkNotificationAsReadDocument: Apollo.DocumentNode;
+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 declare function useMarkNotificationAsReadMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>): Apollo.MutationTuple<IMarkNotificationAsReadMutation, Exact<{
+    notificationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type MarkNotificationAsReadMutationHookResult = ReturnType<typeof useMarkNotificationAsReadMutation>;
+export type MarkNotificationAsReadMutationResult = Apollo.MutationResult<IMarkNotificationAsReadMutation>;
+export type MarkNotificationAsReadMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsReadMutation, IMarkNotificationAsReadMutationVariables>;
+export declare const MarkNotificationAsShownDocument: Apollo.DocumentNode;
+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 declare function useMarkNotificationAsShownMutation(baseOptions?: Apollo.MutationHookOptions<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>): Apollo.MutationTuple<IMarkNotificationAsShownMutation, Exact<{
+    notificationId: string;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type MarkNotificationAsShownMutationHookResult = ReturnType<typeof useMarkNotificationAsShownMutation>;
+export type MarkNotificationAsShownMutationResult = Apollo.MutationResult<IMarkNotificationAsShownMutation>;
+export type MarkNotificationAsShownMutationOptions = Apollo.BaseMutationOptions<IMarkNotificationAsShownMutation, IMarkNotificationAsShownMutationVariables>;
+export declare const StartFarmingDocument: Apollo.DocumentNode;
+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 declare function useStartFarmingMutation(baseOptions?: Apollo.MutationHookOptions<IStartFarmingMutation, IStartFarmingMutationVariables>): Apollo.MutationTuple<IStartFarmingMutation, Exact<{
+    [key: string]: never;
+}>, Apollo.DefaultContext, Apollo.ApolloCache<any>>;
+export type StartFarmingMutationHookResult = ReturnType<typeof useStartFarmingMutation>;
+export type StartFarmingMutationResult = Apollo.MutationResult<IStartFarmingMutation>;
+export type StartFarmingMutationOptions = Apollo.BaseMutationOptions<IStartFarmingMutation, IStartFarmingMutationVariables>;
+export declare const FetchFrensDataDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchFrensDataQuery(baseOptions?: Apollo.QueryHookOptions<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>): Apollo.QueryResult<IFetchFrensDataQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchFrensDataLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>): Apollo.LazyQueryResultTuple<IFetchFrensDataQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchFrensDataQueryHookResult = ReturnType<typeof useFetchFrensDataQuery>;
+export type FetchFrensDataLazyQueryHookResult = ReturnType<typeof useFetchFrensDataLazyQuery>;
+export type FetchFrensDataQueryResult = Apollo.QueryResult<IFetchFrensDataQuery, IFetchFrensDataQueryVariables>;
+export declare const FetchPlayerStateDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useFetchPlayerStateQuery(baseOptions?: Apollo.QueryHookOptions<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>): Apollo.QueryResult<IFetchPlayerStateQuery, Exact<{
+    [key: string]: never;
+}>>;
+export declare function useFetchPlayerStateLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>): Apollo.LazyQueryResultTuple<IFetchPlayerStateQuery, Exact<{
+    [key: string]: never;
+}>>;
+export type FetchPlayerStateQueryHookResult = ReturnType<typeof useFetchPlayerStateQuery>;
+export type FetchPlayerStateLazyQueryHookResult = ReturnType<typeof useFetchPlayerStateLazyQuery>;
+export type FetchPlayerStateQueryResult = Apollo.QueryResult<IFetchPlayerStateQuery, IFetchPlayerStateQueryVariables>;
+export declare const OnPlayerStateUpdatedDocument: Apollo.DocumentNode;
+/**
+ * __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 declare function useOnPlayerStateUpdatedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnPlayerStateUpdatedSubscription, IOnPlayerStateUpdatedSubscriptionVariables>): {
+    restart(): void;
+    loading: boolean;
+    data?: IOnPlayerStateUpdatedSubscription | undefined;
+    error?: Apollo.ApolloError | undefined;
+    variables?: Exact<{
+        authToken: string;
+    }> | undefined;
+};
+export type OnPlayerStateUpdatedSubscriptionHookResult = ReturnType<typeof useOnPlayerStateUpdatedSubscription>;
+export type OnPlayerStateUpdatedSubscriptionResult = Apollo.SubscriptionResult<IOnPlayerStateUpdatedSubscription>;