@ludo.ninja/api 2.8.28 → 2.8.30

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

@@ -0,0 +1,482 @@
+/* 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 IAsset = {
+  assetId: Scalars['ID'];
+  blockchain?: Maybe<Scalars['String']>;
+  blockchainLabel?: Maybe<Scalars['String']>;
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  collection?: Maybe<Scalars['String']>;
+  id?: Maybe<Scalars['String']>;
+  chainId?: Maybe<Scalars['String']>;
+  blockHeight?: Maybe<Scalars['Long']>;
+  blockTimestamp?: Maybe<Scalars['Long']>;
+  name?: Maybe<Scalars['String']>;
+  description?: Maybe<Scalars['String']>;
+  originalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  medias?: Maybe<Array<Maybe<IMedia>>>;
+  ownersAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
+  creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']>>>;
+  creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
+  attributes?: Maybe<Array<Maybe<IAttribute>>>;
+  likes?: Maybe<Scalars['Int']>;
+  views?: Maybe<Scalars['Int']>;
+  visible?: Maybe<Scalars['Boolean']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  blurred?: Maybe<Scalars['Boolean']>;
+  rank?: Maybe<Scalars['Float']>;
+  trueRank?: Maybe<Scalars['Float']>;
+  collectionId?: Maybe<Scalars['String']>;
+  collectionTitle?: Maybe<Scalars['String']>;
+  collectionOriginalUrls?: Maybe<Array<Maybe<Scalars['String']>>>;
+  collectionMedias?: Maybe<Array<Maybe<IMedia>>>;
+  markets?: Maybe<Array<Maybe<IAssetMarket>>>;
+  latestPriceBlockHeight?: Maybe<Scalars['Long']>;
+  latestPriceCurrency?: Maybe<Scalars['String']>;
+  latestPriceAmount?: Maybe<Scalars['Float']>;
+  totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
+  category?: Maybe<Scalars['String']>;
+  categoryLabel?: Maybe<Scalars['String']>;
+};
+
+export type IAssetMarket = {
+  marketId?: Maybe<Scalars['String']>;
+  marketName?: Maybe<Scalars['String']>;
+  marketDomain?: Maybe<Scalars['String']>;
+  marketUrl?: Maybe<Scalars['String']>;
+};
+
+export type IAttribute = {
+  name?: Maybe<Scalars['String']>;
+  value?: Maybe<Scalars['String']>;
+};
+
+export type ICurrencyAmountPair = {
+  currency?: Maybe<Scalars['String']>;
+  amount?: Maybe<Scalars['Float']>;
+};
+
+export type IDynamicAssetData = {
+  assetId: Scalars['String'];
+  isLikedByUser?: Maybe<Scalars['Boolean']>;
+  likesNum?: Maybe<Scalars['Int']>;
+  medias?: Maybe<Array<Maybe<IMedia>>>;
+};
+
+
+export type IMedia = {
+  originalUrl?: Maybe<Scalars['String']>;
+  url?: Maybe<Scalars['String']>;
+  previewUrl?: Maybe<Scalars['String']>;
+  mimeType?: Maybe<Scalars['String']>;
+  sizeRatio?: Maybe<Scalars['Float']>;
+  fileSize?: Maybe<Scalars['Long']>;
+  nsfw?: Maybe<Scalars['Int']>;
+  originalMime?: Maybe<Scalars['String']>;
+  hidden?: Maybe<Scalars['Boolean']>;
+  cover?: Maybe<Scalars['Boolean']>;
+};
+
+export type IMutation = {
+  setDummy: Scalars['String'];
+  likeAsset: Scalars['Boolean'];
+  dislikeAsset: Scalars['Boolean'];
+};
+
+
+export type IMutationLikeAssetArgs = {
+  assetId: Scalars['String'];
+};
+
+
+export type IMutationDislikeAssetArgs = {
+  assetId: Scalars['String'];
+};
+
+export type IProfile = {
+  userId: Scalars['ID'];
+  username?: Maybe<Scalars['String']>;
+  about?: Maybe<Scalars['String']>;
+  userpic?: Maybe<Scalars['String']>;
+  followers?: Maybe<Scalars['Int']>;
+  followings?: Maybe<Scalars['Int']>;
+  createdAt?: Maybe<Scalars['Long']>;
+  deletedAt?: Maybe<Scalars['Long']>;
+  visible?: Maybe<Scalars['Boolean']>;
+  views?: Maybe<Scalars['Int']>;
+  deleted?: Maybe<Scalars['Boolean']>;
+};
+
+/** scalar Upload */
+export type IQuery = {
+  getDummy: Scalars['String'];
+  fetchAssetByBlockchain: IAsset;
+  fetchDynamicAssetData: IDynamicAssetData;
+  fetchDynamicAssetsData: Array<Maybe<IDynamicAssetData>>;
+  fetchAssets: Array<Maybe<IAsset>>;
+};
+
+
+/** scalar Upload */
+export type IQueryFetchAssetByBlockchainArgs = {
+  blockchain: Scalars['String'];
+  address?: Maybe<Scalars['String']>;
+  tokenId?: Maybe<Scalars['String']>;
+  elrondId?: Maybe<Scalars['String']>;
+};
+
+
+/** scalar Upload */
+export type IQueryFetchDynamicAssetDataArgs = {
+  assetId: Scalars['String'];
+};
+
+
+/** scalar Upload */
+export type IQueryFetchDynamicAssetsDataArgs = {
+  assetIds: Array<Scalars['String']>;
+};
+
+
+/** scalar Upload */
+export type IQueryFetchAssetsArgs = {
+  assetIds: Array<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 = {
+  Asset: ResolverTypeWrapper<IAsset>;
+  ID: ResolverTypeWrapper<Scalars['ID']>;
+  String: ResolverTypeWrapper<Scalars['String']>;
+  Int: ResolverTypeWrapper<Scalars['Int']>;
+  Boolean: ResolverTypeWrapper<Scalars['Boolean']>;
+  Float: ResolverTypeWrapper<Scalars['Float']>;
+  AssetMarket: ResolverTypeWrapper<IAssetMarket>;
+  Attribute: ResolverTypeWrapper<IAttribute>;
+  CurrencyAmountPair: ResolverTypeWrapper<ICurrencyAmountPair>;
+  DynamicAssetData: ResolverTypeWrapper<IDynamicAssetData>;
+  Long: ResolverTypeWrapper<Scalars['Long']>;
+  Media: ResolverTypeWrapper<IMedia>;
+  Mutation: ResolverTypeWrapper<{}>;
+  Profile: ResolverTypeWrapper<IProfile>;
+  Query: ResolverTypeWrapper<{}>;
+};
+
+/** Mapping between all available schema types and the resolvers parents */
+export type IResolversParentTypes = {
+  Asset: IAsset;
+  ID: Scalars['ID'];
+  String: Scalars['String'];
+  Int: Scalars['Int'];
+  Boolean: Scalars['Boolean'];
+  Float: Scalars['Float'];
+  AssetMarket: IAssetMarket;
+  Attribute: IAttribute;
+  CurrencyAmountPair: ICurrencyAmountPair;
+  DynamicAssetData: IDynamicAssetData;
+  Long: Scalars['Long'];
+  Media: IMedia;
+  Mutation: {};
+  Profile: IProfile;
+  Query: {};
+};
+
+export type IOneOfDirectiveArgs = { };
+
+export type IOneOfDirectiveResolver<Result, Parent, ContextType = any, Args = IOneOfDirectiveArgs> = DirectiveResolverFn<Result, Parent, ContextType, Args>;
+
+export type IAssetResolvers<ContextType = any, ParentType extends IResolversParentTypes['Asset'] = IResolversParentTypes['Asset']> = {
+  assetId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  blockchain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  blockchainLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  address?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collection?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  chainId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  blockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  blockTimestamp?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  originalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  ownersAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  ownersProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
+  creatorsAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  creatorsProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
+  attributes?: Resolver<Maybe<Array<Maybe<IResolversTypes['Attribute']>>>, ParentType, ContextType>;
+  likes?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  blurred?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  trueRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  collectionId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  collectionOriginalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
+  collectionMedias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  markets?: Resolver<Maybe<Array<Maybe<IResolversTypes['AssetMarket']>>>, ParentType, ContextType>;
+  latestPriceBlockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  latestPriceCurrency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  latestPriceAmount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  totalVolumes?: Resolver<Maybe<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>>, ParentType, ContextType>;
+  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  categoryLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAssetMarketResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetMarket'] = IResolversParentTypes['AssetMarket']> = {
+  marketId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketName?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketDomain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  marketUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IAttributeResolvers<ContextType = any, ParentType extends IResolversParentTypes['Attribute'] = IResolversParentTypes['Attribute']> = {
+  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  value?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type ICurrencyAmountPairResolvers<ContextType = any, ParentType extends IResolversParentTypes['CurrencyAmountPair'] = IResolversParentTypes['CurrencyAmountPair']> = {
+  currency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  amount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IDynamicAssetDataResolvers<ContextType = any, ParentType extends IResolversParentTypes['DynamicAssetData'] = IResolversParentTypes['DynamicAssetData']> = {
+  assetId?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  isLikedByUser?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  likesNum?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export interface ILongScalarConfig extends GraphQLScalarTypeConfig<IResolversTypes['Long'], any> {
+  name: 'Long';
+}
+
+export type IMediaResolvers<ContextType = any, ParentType extends IResolversParentTypes['Media'] = IResolversParentTypes['Media']> = {
+  originalUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  previewUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  mimeType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  sizeRatio?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
+  fileSize?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  nsfw?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  originalMime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  hidden?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  cover?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
+  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  likeAsset?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationLikeAssetArgs, 'assetId'>>;
+  dislikeAsset?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationDislikeAssetArgs, 'assetId'>>;
+};
+
+export type IProfileResolvers<ContextType = any, ParentType extends IResolversParentTypes['Profile'] = IResolversParentTypes['Profile']> = {
+  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
+  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  about?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  userpic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
+  followers?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  followings?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  deletedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
+  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
+  deleted?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
+  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
+};
+
+export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
+  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
+  fetchAssetByBlockchain?: Resolver<IResolversTypes['Asset'], ParentType, ContextType, RequireFields<IQueryFetchAssetByBlockchainArgs, 'blockchain'>>;
+  fetchDynamicAssetData?: Resolver<IResolversTypes['DynamicAssetData'], ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetDataArgs, 'assetId'>>;
+  fetchDynamicAssetsData?: Resolver<Array<Maybe<IResolversTypes['DynamicAssetData']>>, ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetsDataArgs, 'assetIds'>>;
+  fetchAssets?: Resolver<Array<Maybe<IResolversTypes['Asset']>>, ParentType, ContextType, RequireFields<IQueryFetchAssetsArgs, 'assetIds'>>;
+};
+
+export type IResolvers<ContextType = any> = {
+  Asset?: IAssetResolvers<ContextType>;
+  AssetMarket?: IAssetMarketResolvers<ContextType>;
+  Attribute?: IAttributeResolvers<ContextType>;
+  CurrencyAmountPair?: ICurrencyAmountPairResolvers<ContextType>;
+  DynamicAssetData?: IDynamicAssetDataResolvers<ContextType>;
+  Long?: GraphQLScalarType;
+  Media?: IMediaResolvers<ContextType>;
+  Mutation?: IMutationResolvers<ContextType>;
+  Profile?: IProfileResolvers<ContextType>;
+  Query?: IQueryResolvers<ContextType>;
+};
+
+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 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>;