@ludo.ninja/api 3.2.43 → 3.2.45

package/build/index.d.ts

@@ -227,6 +227,16 @@ declare const schema: {
     SubmitPartnershipInquiryDocument: import("graphql").DocumentNode;
     SubmitRegistrationInviteDocument: import("graphql").DocumentNode;
     SubmitUserFeedbackDocument: import("graphql").DocumentNode;
+    useDislikeAssetMutation(baseOptions?: import("@apollo/client").MutationHookOptions<searchSchema.IDislikeAssetMutation, searchSchema.Exact<{
+        assetId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<searchSchema.IDislikeAssetMutation, searchSchema.Exact<{
+        assetId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
+    useLikeAssetMutation(baseOptions?: import("@apollo/client").MutationHookOptions<searchSchema.ILikeAssetMutation, searchSchema.Exact<{
+        assetId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<searchSchema.ILikeAssetMutation, searchSchema.Exact<{
+        assetId: string;
+    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
     useFetchAirdropsLeaderboardQuery(baseOptions: import("@apollo/client").QueryHookOptions<searchSchema.IFetchAirdropsLeaderboardQuery, searchSchema.Exact<{
         filter: searchSchema.IAirdropsLeaderboardFilterInput;
         sort: searchSchema.IAirdropsLeaderboardSortInput;
@@ -608,6 +618,8 @@ declare const schema: {
     IProjectType: typeof searchSchema.IProjectType;
     IReftypeColor: typeof searchSchema.IReftypeColor;
     ISortDirection: typeof searchSchema.ISortDirection;
+    DislikeAssetDocument: import("graphql").DocumentNode;
+    LikeAssetDocument: import("graphql").DocumentNode;
     FetchAirdropsLeaderboardDocument: import("graphql").DocumentNode;
     FetchAllCreationsDocument: import("graphql").DocumentNode;
     FetchAssetByBlockchainDocument: import("graphql").DocumentNode;
@@ -1660,14 +1672,14 @@ declare const schema: {
     }>> | undefined): import("@apollo/client").LazyQueryResultTuple<experiencesSchema.IFetchMyActivityStreakQuery, experiencesSchema.Exact<{
         [key: string]: never;
     }>>;
-    useFetchMyExperienceV2Query(baseOptions?: import("@apollo/client").QueryHookOptions<experiencesSchema.IFetchMyExperienceV2Query, experiencesSchema.Exact<{
+    useFetchMyExperienceQuery(baseOptions?: import("@apollo/client").QueryHookOptions<experiencesSchema.IFetchMyExperienceQuery, experiencesSchema.Exact<{
         [key: string]: never;
-    }>> | undefined): import("@apollo/client").QueryResult<experiencesSchema.IFetchMyExperienceV2Query, experiencesSchema.Exact<{
+    }>> | undefined): import("@apollo/client").QueryResult<experiencesSchema.IFetchMyExperienceQuery, experiencesSchema.Exact<{
         [key: string]: never;
     }>>;
-    useFetchMyExperienceV2LazyQuery(baseOptions?: import("@apollo/client").LazyQueryHookOptions<experiencesSchema.IFetchMyExperienceV2Query, experiencesSchema.Exact<{
+    useFetchMyExperienceLazyQuery(baseOptions?: import("@apollo/client").LazyQueryHookOptions<experiencesSchema.IFetchMyExperienceQuery, experiencesSchema.Exact<{
         [key: string]: never;
-    }>> | undefined): import("@apollo/client").LazyQueryResultTuple<experiencesSchema.IFetchMyExperienceV2Query, experiencesSchema.Exact<{
+    }>> | undefined): import("@apollo/client").LazyQueryResultTuple<experiencesSchema.IFetchMyExperienceQuery, experiencesSchema.Exact<{
         [key: string]: never;
     }>>;
     useFetchMyMonthReferralsXpsQuery(baseOptions?: import("@apollo/client").QueryHookOptions<experiencesSchema.IFetchMyMonthReferralsXpsQuery, experiencesSchema.Exact<{
@@ -1690,40 +1702,10 @@ declare const schema: {
     }>> | undefined): import("@apollo/client").LazyQueryResultTuple<experiencesSchema.IFetchMyTasksQuery, experiencesSchema.Exact<{
         [key: string]: never;
     }>>;
-    useOnCommonOpportunityNotificationSubscription(baseOptions?: import("@apollo/client").SubscriptionHookOptions<experiencesSchema.IOnCommonOpportunityNotificationSubscription, experiencesSchema.Exact<{
-        [key: string]: never;
-    }>> | undefined): import("@apollo/client").SubscriptionResult<experiencesSchema.IOnCommonOpportunityNotificationSubscription, experiencesSchema.Exact<{
-        [key: string]: never;
-    }>>;
-    useOnInviteCodeUsedSubscription(baseOptions: import("@apollo/client").SubscriptionHookOptions<experiencesSchema.IOnInviteCodeUsedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>): import("@apollo/client").SubscriptionResult<experiencesSchema.IOnInviteCodeUsedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>;
-    useOnMyExperienceIncrementedSubscription(baseOptions: import("@apollo/client").SubscriptionHookOptions<experiencesSchema.IOnMyExperienceIncrementedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>): import("@apollo/client").SubscriptionResult<experiencesSchema.IOnMyExperienceIncrementedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>;
-    useOnMyExperienceUpdatedSubscription(baseOptions: import("@apollo/client").SubscriptionHookOptions<experiencesSchema.IOnMyExperienceUpdatedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>): import("@apollo/client").SubscriptionResult<experiencesSchema.IOnMyExperienceUpdatedSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>;
-    useOnUserOpportunityNotificationSubscription(baseOptions: import("@apollo/client").SubscriptionHookOptions<experiencesSchema.IOnUserOpportunityNotificationSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>): import("@apollo/client").SubscriptionResult<experiencesSchema.IOnUserOpportunityNotificationSubscription, experiencesSchema.Exact<{
-        authToken: string;
-    }>>;
     FetchMyActivityStreakDocument: import("graphql").DocumentNode;
-    FetchMyExperienceV2Document: import("graphql").DocumentNode;
+    FetchMyExperienceDocument: import("graphql").DocumentNode;
     FetchMyMonthReferralsXpsDocument: import("graphql").DocumentNode;
     FetchMyTasksDocument: import("graphql").DocumentNode;
-    OnCommonOpportunityNotificationDocument: import("graphql").DocumentNode;
-    OnInviteCodeUsedDocument: import("graphql").DocumentNode;
-    OnMyExperienceIncrementedDocument: import("graphql").DocumentNode;
-    OnMyExperienceUpdatedDocument: import("graphql").DocumentNode;
-    OnUserOpportunityNotificationDocument: import("graphql").DocumentNode;
     useDislikeCollectionMutation(baseOptions?: import("@apollo/client").MutationHookOptions<collectionsSchema.IDislikeCollectionMutation, collectionsSchema.Exact<{
         collectionId: string;
     }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<collectionsSchema.IDislikeCollectionMutation, collectionsSchema.Exact<{
@@ -1750,18 +1732,6 @@ declare const schema: {
     }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
     RefreshTokenDocument: import("graphql").DocumentNode;
     RevokeTokenDocument: import("graphql").DocumentNode;
-    useDislikeAssetMutation(baseOptions?: import("@apollo/client").MutationHookOptions<assetSchema.IDislikeAssetMutation, assetSchema.Exact<{
-        assetId: string;
-    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<assetSchema.IDislikeAssetMutation, assetSchema.Exact<{
-        assetId: string;
-    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
-    useLikeAssetMutation(baseOptions?: import("@apollo/client").MutationHookOptions<assetSchema.ILikeAssetMutation, assetSchema.Exact<{
-        assetId: string;
-    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<assetSchema.ILikeAssetMutation, assetSchema.Exact<{
-        assetId: string;
-    }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>>;
-    DislikeAssetDocument: import("graphql").DocumentNode;
-    LikeAssetDocument: import("graphql").DocumentNode;
     useCreateReferralTypeMutation(baseOptions?: import("@apollo/client").MutationHookOptions<adminSchema.ICreateReferralTypeMutation, adminSchema.Exact<{
         input: adminSchema.IReferralTypeInput;
     }>, import("@apollo/client").DefaultContext, import("@apollo/client").ApolloCache<any>> | undefined): import("@apollo/client").MutationTuple<adminSchema.ICreateReferralTypeMutation, adminSchema.Exact<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ludo.ninja/api",
-  "version": "3.2.43",
+  "version": "3.2.45",
   "main": "./build/index.js",
   "scripts": {
     "test": "jest",

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

@@ -6,7 +6,6 @@ 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;
@@ -19,6 +18,8 @@ export type Scalars = {
 };
 
 
+
+
 export type IActivityStreak = {
   userId: Scalars['ID'];
   totalDays: Scalars['Int'];
@@ -52,31 +53,6 @@ export type IQuery = {
 
 export type ISubscription = {
   onDummy: Scalars['String'];
-  onMyExperienceUpdated: IUserXp;
-  onMyExperienceIncremented: IUserXpIncrement;
-  onInviteCodeUsed: IUsedInviteCode;
-  onCommonOpportunityNotification: IOpportunityNotification;
-  onUserOpportunityNotification: IOpportunityNotification;
-};
-
-
-export type ISubscriptionOnMyExperienceUpdatedArgs = {
-  authToken: Scalars['String'];
-};
-
-
-export type ISubscriptionOnMyExperienceIncrementedArgs = {
-  authToken: Scalars['String'];
-};
-
-
-export type ISubscriptionOnInviteCodeUsedArgs = {
-  authToken: Scalars['String'];
-};
-
-
-export type ISubscriptionOnUserOpportunityNotificationArgs = {
-  authToken: Scalars['String'];
 };
 
 export type ITask = {
@@ -218,6 +194,17 @@ export type IResolversParentTypes = {
   UserXPIncrement: IUserXpIncrement;
 };
 
+export type IDeferDirectiveArgs = {
+  if?: Scalars['Boolean'];
+  label?: Maybe<Scalars['String']>;
+};
+
+export type IDeferDirectiveResolver<Result, Parent, ContextType = any, Args = IDeferDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IExperimental_DisableErrorPropagationDirectiveArgs = { };
+
+export type IExperimental_DisableErrorPropagationDirectiveResolver<Result, Parent, ContextType = any, Args = IExperimental_DisableErrorPropagationDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
 export type IOneOfDirectiveArgs = { };
 
 export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
@@ -260,11 +247,6 @@ export type IQueryResolvers<ContextType = any, ParentType extends IResolversPare
 
 export type ISubscriptionResolvers<ContextType = any, ParentType extends IResolversParentTypes['Subscription'] = IResolversParentTypes['Subscription']> = {
   onDummy?: SubscriptionResolver<IResolversTypes['String'], "onDummy", ParentType, ContextType>;
-  onMyExperienceUpdated?: SubscriptionResolver<IResolversTypes['UserXP'], "onMyExperienceUpdated", ParentType, ContextType, RequireFields<ISubscriptionOnMyExperienceUpdatedArgs, 'authToken'>>;
-  onMyExperienceIncremented?: SubscriptionResolver<IResolversTypes['UserXPIncrement'], "onMyExperienceIncremented", ParentType, ContextType, RequireFields<ISubscriptionOnMyExperienceIncrementedArgs, 'authToken'>>;
-  onInviteCodeUsed?: SubscriptionResolver<IResolversTypes['UsedInviteCode'], "onInviteCodeUsed", ParentType, ContextType, RequireFields<ISubscriptionOnInviteCodeUsedArgs, 'authToken'>>;
-  onCommonOpportunityNotification?: SubscriptionResolver<IResolversTypes['OpportunityNotification'], "onCommonOpportunityNotification", ParentType, ContextType>;
-  onUserOpportunityNotification?: SubscriptionResolver<IResolversTypes['OpportunityNotification'], "onUserOpportunityNotification", ParentType, ContextType, RequireFields<ISubscriptionOnUserOpportunityNotificationArgs, 'authToken'>>;
 };
 
 export type ITaskResolvers<ContextType = any, ParentType extends IResolversParentTypes['Task'] = IResolversParentTypes['Task']> = {
@@ -321,6 +303,8 @@ export type IResolvers<ContextType = any> = {
 };
 
 export type IDirectiveResolvers<ContextType = any> = {
+  defer?: IDeferDirectiveResolver<any, any, ContextType>;
+  experimental_disableErrorPropagation?: IExperimental_DisableErrorPropagationDirectiveResolver<any, any, ContextType>;
   oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
 };
 
@@ -329,10 +313,10 @@ export type IFetchMyActivityStreakQueryVariables = Exact<{ [key: string]: never;
 
 export type IFetchMyActivityStreakQuery = { fetchMyActivityStreak?: Maybe<Pick<IActivityStreak, 'userId' | 'totalDays' | 'nextStreak' | 'nextBonus'>> };
 
-export type IFetchMyExperienceV2QueryVariables = Exact<{ [key: string]: never; }>;
+export type IFetchMyExperienceQueryVariables = Exact<{ [key: string]: never; }>;
 
 
-export type IFetchMyExperienceV2Query = { fetchMyExperienceV2: Pick<IUserXp, 'xps' | 'level' | 'levelMaxXps' | 'levelMinXps'> };
+export type IFetchMyExperienceQuery = Pick<IQuery, 'fetchMyExperience'>;
 
 export type IFetchMyMonthReferralsXpsQueryVariables = Exact<{ [key: string]: never; }>;
 
@@ -344,39 +328,6 @@ export type IFetchMyTasksQueryVariables = Exact<{ [key: string]: never; }>;
 
 export type IFetchMyTasksQuery = { fetchMyTasks: Array<Maybe<Pick<ITask, 'taskId' | 'userId' | 'taskType' | 'name' | 'description' | 'repeatable' | 'maxRepeats' | 'minPointsAward' | 'maxPointsAward' | 'repeatsCompleted'>>> };
 
-export type IOnCommonOpportunityNotificationSubscriptionVariables = Exact<{ [key: string]: never; }>;
-
-
-export type IOnCommonOpportunityNotificationSubscription = { onCommonOpportunityNotification: Pick<IOpportunityNotification, 'opportunityId' | 'name' | 'description' | 'notificationType' | 'media' | 'projectUrl'> };
-
-export type IOnInviteCodeUsedSubscriptionVariables = Exact<{
-  authToken: Scalars['String'];
-}>;
-
-
-export type IOnInviteCodeUsedSubscription = { onInviteCodeUsed: Pick<IUsedInviteCode, 'userId' | 'inviteCode' | 'inviteeId'> };
-
-export type IOnMyExperienceIncrementedSubscriptionVariables = Exact<{
-  authToken: Scalars['String'];
-}>;
-
-
-export type IOnMyExperienceIncrementedSubscription = { onMyExperienceIncremented: Pick<IUserXpIncrement, 'xpsIncrement' | 'description' | 'xps' | 'level' | 'levelMinXps' | 'levelMaxXps'> };
-
-export type IOnMyExperienceUpdatedSubscriptionVariables = Exact<{
-  authToken: Scalars['String'];
-}>;
-
-
-export type IOnMyExperienceUpdatedSubscription = { onMyExperienceUpdated: Pick<IUserXp, 'xps' | 'level' | 'levelMinXps' | 'levelMaxXps'> };
-
-export type IOnUserOpportunityNotificationSubscriptionVariables = Exact<{
-  authToken: Scalars['String'];
-}>;
-
-
-export type IOnUserOpportunityNotificationSubscription = { onUserOpportunityNotification: Pick<IOpportunityNotification, 'opportunityId' | 'name' | 'description' | 'notificationType' | 'media' | 'projectUrl'> };
-
 
 export const FetchMyActivityStreakDocument = gql`
     query FetchMyActivityStreak {
@@ -413,41 +364,36 @@ export function useFetchMyActivityStreakLazyQuery(baseOptions?: Apollo.LazyQuery
 export type FetchMyActivityStreakQueryHookResult = ReturnType<typeof useFetchMyActivityStreakQuery>;
 export type FetchMyActivityStreakLazyQueryHookResult = ReturnType<typeof useFetchMyActivityStreakLazyQuery>;
 export type FetchMyActivityStreakQueryResult = Apollo.QueryResult<IFetchMyActivityStreakQuery, IFetchMyActivityStreakQueryVariables>;
-export const FetchMyExperienceV2Document = gql`
-    query FetchMyExperienceV2 {
-  fetchMyExperienceV2 {
-    xps
-    level
-    levelMaxXps
-    levelMinXps
-  }
+export const FetchMyExperienceDocument = gql`
+    query FetchMyExperience {
+  fetchMyExperience
 }
     `;
 
 /**
- * __useFetchMyExperienceV2Query__
+ * __useFetchMyExperienceQuery__
  *
- * To run a query within a React component, call `useFetchMyExperienceV2Query` and pass it any options that fit your needs.
- * When your component renders, `useFetchMyExperienceV2Query` returns an object from Apollo Client that contains loading, error, and data properties
+ * To run a query within a React component, call `useFetchMyExperienceQuery` and pass it any options that fit your needs.
+ * When your component renders, `useFetchMyExperienceQuery` 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 } = useFetchMyExperienceV2Query({
+ * const { data, loading, error } = useFetchMyExperienceQuery({
  *   variables: {
  *   },
  * });
  */
-export function useFetchMyExperienceV2Query(baseOptions?: Apollo.QueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>) {
-        return Apollo.useQuery<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>(FetchMyExperienceV2Document, baseOptions);
+export function useFetchMyExperienceQuery(baseOptions?: Apollo.QueryHookOptions<IFetchMyExperienceQuery, IFetchMyExperienceQueryVariables>) {
+        return Apollo.useQuery<IFetchMyExperienceQuery, IFetchMyExperienceQueryVariables>(FetchMyExperienceDocument, baseOptions);
       }
-export function useFetchMyExperienceV2LazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>) {
-          return Apollo.useLazyQuery<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>(FetchMyExperienceV2Document, baseOptions);
+export function useFetchMyExperienceLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchMyExperienceQuery, IFetchMyExperienceQueryVariables>) {
+          return Apollo.useLazyQuery<IFetchMyExperienceQuery, IFetchMyExperienceQueryVariables>(FetchMyExperienceDocument, baseOptions);
         }
-export type FetchMyExperienceV2QueryHookResult = ReturnType<typeof useFetchMyExperienceV2Query>;
-export type FetchMyExperienceV2LazyQueryHookResult = ReturnType<typeof useFetchMyExperienceV2LazyQuery>;
-export type FetchMyExperienceV2QueryResult = Apollo.QueryResult<IFetchMyExperienceV2Query, IFetchMyExperienceV2QueryVariables>;
+export type FetchMyExperienceQueryHookResult = ReturnType<typeof useFetchMyExperienceQuery>;
+export type FetchMyExperienceLazyQueryHookResult = ReturnType<typeof useFetchMyExperienceLazyQuery>;
+export type FetchMyExperienceQueryResult = Apollo.QueryResult<IFetchMyExperienceQuery, IFetchMyExperienceQueryVariables>;
 export const FetchMyMonthReferralsXpsDocument = gql`
     query FetchMyMonthReferralsXps {
   fetchMyMonthReferralsXps
@@ -518,168 +464,4 @@ export function useFetchMyTasksLazyQuery(baseOptions?: Apollo.LazyQueryHookOptio
         }
 export type FetchMyTasksQueryHookResult = ReturnType<typeof useFetchMyTasksQuery>;
 export type FetchMyTasksLazyQueryHookResult = ReturnType<typeof useFetchMyTasksLazyQuery>;
-export type FetchMyTasksQueryResult = Apollo.QueryResult<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>;
-export const OnCommonOpportunityNotificationDocument = gql`
-    subscription OnCommonOpportunityNotification {
-  onCommonOpportunityNotification {
-    opportunityId
-    name
-    description
-    notificationType
-    media
-    projectUrl
-  }
-}
-    `;
-
-/**
- * __useOnCommonOpportunityNotificationSubscription__
- *
- * To run a query within a React component, call `useOnCommonOpportunityNotificationSubscription` and pass it any options that fit your needs.
- * When your component renders, `useOnCommonOpportunityNotificationSubscription` 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 } = useOnCommonOpportunityNotificationSubscription({
- *   variables: {
- *   },
- * });
- */
-export function useOnCommonOpportunityNotificationSubscription(baseOptions?: Apollo.SubscriptionHookOptions<IOnCommonOpportunityNotificationSubscription, IOnCommonOpportunityNotificationSubscriptionVariables>) {
-        return Apollo.useSubscription<IOnCommonOpportunityNotificationSubscription, IOnCommonOpportunityNotificationSubscriptionVariables>(OnCommonOpportunityNotificationDocument, baseOptions);
-      }
-export type OnCommonOpportunityNotificationSubscriptionHookResult = ReturnType<typeof useOnCommonOpportunityNotificationSubscription>;
-export type OnCommonOpportunityNotificationSubscriptionResult = Apollo.SubscriptionResult<IOnCommonOpportunityNotificationSubscription>;
-export const OnInviteCodeUsedDocument = gql`
-    subscription onInviteCodeUsed($authToken: String!) {
-  onInviteCodeUsed(authToken: $authToken) {
-    userId
-    inviteCode
-    inviteeId
-  }
-}
-    `;
-
-/**
- * __useOnInviteCodeUsedSubscription__
- *
- * To run a query within a React component, call `useOnInviteCodeUsedSubscription` and pass it any options that fit your needs.
- * When your component renders, `useOnInviteCodeUsedSubscription` 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 } = useOnInviteCodeUsedSubscription({
- *   variables: {
- *      authToken: // value for 'authToken'
- *   },
- * });
- */
-export function useOnInviteCodeUsedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnInviteCodeUsedSubscription, IOnInviteCodeUsedSubscriptionVariables>) {
-        return Apollo.useSubscription<IOnInviteCodeUsedSubscription, IOnInviteCodeUsedSubscriptionVariables>(OnInviteCodeUsedDocument, baseOptions);
-      }
-export type OnInviteCodeUsedSubscriptionHookResult = ReturnType<typeof useOnInviteCodeUsedSubscription>;
-export type OnInviteCodeUsedSubscriptionResult = Apollo.SubscriptionResult<IOnInviteCodeUsedSubscription>;
-export const OnMyExperienceIncrementedDocument = gql`
-    subscription onMyExperienceIncremented($authToken: String!) {
-  onMyExperienceIncremented(authToken: $authToken) {
-    xpsIncrement
-    description
-    xps
-    level
-    levelMinXps
-    levelMaxXps
-  }
-}
-    `;
-
-/**
- * __useOnMyExperienceIncrementedSubscription__
- *
- * To run a query within a React component, call `useOnMyExperienceIncrementedSubscription` and pass it any options that fit your needs.
- * When your component renders, `useOnMyExperienceIncrementedSubscription` 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 } = useOnMyExperienceIncrementedSubscription({
- *   variables: {
- *      authToken: // value for 'authToken'
- *   },
- * });
- */
-export function useOnMyExperienceIncrementedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceIncrementedSubscription, IOnMyExperienceIncrementedSubscriptionVariables>) {
-        return Apollo.useSubscription<IOnMyExperienceIncrementedSubscription, IOnMyExperienceIncrementedSubscriptionVariables>(OnMyExperienceIncrementedDocument, baseOptions);
-      }
-export type OnMyExperienceIncrementedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceIncrementedSubscription>;
-export type OnMyExperienceIncrementedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceIncrementedSubscription>;
-export const OnMyExperienceUpdatedDocument = gql`
-    subscription OnMyExperienceUpdated($authToken: String!) {
-  onMyExperienceUpdated(authToken: $authToken) {
-    xps
-    level
-    levelMinXps
-    levelMaxXps
-  }
-}
-    `;
-
-/**
- * __useOnMyExperienceUpdatedSubscription__
- *
- * To run a query within a React component, call `useOnMyExperienceUpdatedSubscription` and pass it any options that fit your needs.
- * When your component renders, `useOnMyExperienceUpdatedSubscription` 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 } = useOnMyExperienceUpdatedSubscription({
- *   variables: {
- *      authToken: // value for 'authToken'
- *   },
- * });
- */
-export function useOnMyExperienceUpdatedSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnMyExperienceUpdatedSubscription, IOnMyExperienceUpdatedSubscriptionVariables>) {
-        return Apollo.useSubscription<IOnMyExperienceUpdatedSubscription, IOnMyExperienceUpdatedSubscriptionVariables>(OnMyExperienceUpdatedDocument, baseOptions);
-      }
-export type OnMyExperienceUpdatedSubscriptionHookResult = ReturnType<typeof useOnMyExperienceUpdatedSubscription>;
-export type OnMyExperienceUpdatedSubscriptionResult = Apollo.SubscriptionResult<IOnMyExperienceUpdatedSubscription>;
-export const OnUserOpportunityNotificationDocument = gql`
-    subscription OnUserOpportunityNotification($authToken: String!) {
-  onUserOpportunityNotification(authToken: $authToken) {
-    opportunityId
-    name
-    description
-    notificationType
-    media
-    projectUrl
-  }
-}
-    `;
-
-/**
- * __useOnUserOpportunityNotificationSubscription__
- *
- * To run a query within a React component, call `useOnUserOpportunityNotificationSubscription` and pass it any options that fit your needs.
- * When your component renders, `useOnUserOpportunityNotificationSubscription` 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 } = useOnUserOpportunityNotificationSubscription({
- *   variables: {
- *      authToken: // value for 'authToken'
- *   },
- * });
- */
-export function useOnUserOpportunityNotificationSubscription(baseOptions: Apollo.SubscriptionHookOptions<IOnUserOpportunityNotificationSubscription, IOnUserOpportunityNotificationSubscriptionVariables>) {
-        return Apollo.useSubscription<IOnUserOpportunityNotificationSubscription, IOnUserOpportunityNotificationSubscriptionVariables>(OnUserOpportunityNotificationDocument, baseOptions);
-      }
-export type OnUserOpportunityNotificationSubscriptionHookResult = ReturnType<typeof useOnUserOpportunityNotificationSubscription>;
-export type OnUserOpportunityNotificationSubscriptionResult = Apollo.SubscriptionResult<IOnUserOpportunityNotificationSubscription>;
+export type FetchMyTasksQueryResult = Apollo.QueryResult<IFetchMyTasksQuery, IFetchMyTasksQueryVariables>;

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

@@ -1396,6 +1396,20 @@ export type IDirectiveResolvers<ContextType = any> = {
   oneOf?: IOneOfDirectiveResolver<any, any, ContextType>;
 };
 
+export type IDislikeAssetMutationVariables = Exact<{
+  assetId: Scalars['String'];
+}>;
+
+
+export type IDislikeAssetMutation = Pick<IMutation, 'dislikeAsset'>;
+
+export type ILikeAssetMutationVariables = Exact<{
+  assetId: Scalars['String'];
+}>;
+
+
+export type ILikeAssetMutation = Pick<IMutation, 'likeAsset'>;
+
 export type IFetchAirdropsLeaderboardQueryVariables = Exact<{
   filter: IAirdropsLeaderboardFilterInput;
   sort: IAirdropsLeaderboardSortInput;
@@ -1649,6 +1663,66 @@ export type IFindUserLudoCreationsQueryVariables = Exact<{
 export type IFindUserLudoCreationsQuery = { findUserLudoCreations: { nextPage?: Maybe<Pick<IPage, 'token' | 'num' | 'size' | 'elements'>>, creations: Array<Maybe<Pick<ICreation, 'id' | 'itemType' | 'tokenId' | 'address' | 'itemId' | 'blockchain' | 'rank' | 'name' | 'creatorsAddresses' | 'originalUrls' | 'media' | 'mediaPreview' | 'mimeType' | 'likes'>>> } };
 
 
+export const DislikeAssetDocument = gql`
+    mutation DislikeAsset($assetId: String!) {
+  dislikeAsset(assetId: $assetId)
+}
+    `;
+export type IDislikeAssetMutationFn = Apollo.MutationFunction<IDislikeAssetMutation, IDislikeAssetMutationVariables>;
+
+/**
+ * __useDislikeAssetMutation__
+ *
+ * To run a mutation, you first call `useDislikeAssetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useDislikeAssetMutation` 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 [dislikeAssetMutation, { data, loading, error }] = useDislikeAssetMutation({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export function useDislikeAssetMutation(baseOptions?: Apollo.MutationHookOptions<IDislikeAssetMutation, IDislikeAssetMutationVariables>) {
+        return Apollo.useMutation<IDislikeAssetMutation, IDislikeAssetMutationVariables>(DislikeAssetDocument, baseOptions);
+      }
+export type DislikeAssetMutationHookResult = ReturnType<typeof useDislikeAssetMutation>;
+export type DislikeAssetMutationResult = Apollo.MutationResult<IDislikeAssetMutation>;
+export type DislikeAssetMutationOptions = Apollo.BaseMutationOptions<IDislikeAssetMutation, IDislikeAssetMutationVariables>;
+export const LikeAssetDocument = gql`
+    mutation LikeAsset($assetId: String!) {
+  likeAsset(assetId: $assetId)
+}
+    `;
+export type ILikeAssetMutationFn = Apollo.MutationFunction<ILikeAssetMutation, ILikeAssetMutationVariables>;
+
+/**
+ * __useLikeAssetMutation__
+ *
+ * To run a mutation, you first call `useLikeAssetMutation` within a React component and pass it any options that fit your needs.
+ * When your component renders, `useLikeAssetMutation` 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 [likeAssetMutation, { data, loading, error }] = useLikeAssetMutation({
+ *   variables: {
+ *      assetId: // value for 'assetId'
+ *   },
+ * });
+ */
+export function useLikeAssetMutation(baseOptions?: Apollo.MutationHookOptions<ILikeAssetMutation, ILikeAssetMutationVariables>) {
+        return Apollo.useMutation<ILikeAssetMutation, ILikeAssetMutationVariables>(LikeAssetDocument, baseOptions);
+      }
+export type LikeAssetMutationHookResult = ReturnType<typeof useLikeAssetMutation>;
+export type LikeAssetMutationResult = Apollo.MutationResult<ILikeAssetMutation>;
+export type LikeAssetMutationOptions = Apollo.BaseMutationOptions<ILikeAssetMutation, ILikeAssetMutationVariables>;
 export const FetchAirdropsLeaderboardDocument = gql`
     query FetchAirdropsLeaderboard($filter: AirdropsLeaderboardFilterInput!, $sort: AirdropsLeaderboardSortInput!, $page: PageInput!) {
   fetchAirdropsLeaderboard(filter: $filter, sort: $sort, page: $page) {