@ludo.ninja/api-server-assets

Version:
Visit [Pharos Production](https://pharosproduction.com) – the software development company specializing in high-load Web3 and DeFi projects. We deliver projects on time and within budget!
pharosproduction.com
PharosProduction/software-development-services
457 lines (398 loc) • 22.7 kB
text/typescript
View Raw
/* 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 InputMaybe<T> = Maybe<T>;
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 MakeEmpty<T extends { [key: string]: unknown }, K extends keyof T> = { [_ in K]?: never };
export type Incremental<T> = T | { [P in keyof T]?: P extends ' $fragmentName' | '__typename' ? T[P] : never };
export type RequireFields<T, K extends keyof T> = Omit<T, K> & { [P in K]-?: NonNullable<T[P]> };
const defaultOptions = {} as const;
/** All built-in and custom scalars, mapped to their actual values */
export type Scalars = {
  ID: { input: string; output: string; }
  String: { input: string; output: string; }
  Boolean: { input: boolean; output: boolean; }
  Int: { input: number; output: number; }
  Float: { input: number; output: number; }
  Long: { input: any; output: any; }
};

export type IAsset = {
  address?: Maybe<Scalars['String']['output']>;
  assetId: Scalars['ID']['output'];
  attributes?: Maybe<Array<Maybe<IAttribute>>>;
  blockHeight?: Maybe<Scalars['Long']['output']>;
  blockTimestamp?: Maybe<Scalars['Long']['output']>;
  blockchain?: Maybe<Scalars['String']['output']>;
  blockchainLabel?: Maybe<Scalars['String']['output']>;
  blurred?: Maybe<Scalars['Boolean']['output']>;
  category?: Maybe<Scalars['String']['output']>;
  categoryLabel?: Maybe<Scalars['String']['output']>;
  chainId?: Maybe<Scalars['String']['output']>;
  collection?: Maybe<Scalars['String']['output']>;
  collectionId?: Maybe<Scalars['String']['output']>;
  collectionMedias?: Maybe<Array<Maybe<IMedia>>>;
  collectionOriginalUrls?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  collectionTitle?: Maybe<Scalars['String']['output']>;
  createdAt?: Maybe<Scalars['Long']['output']>;
  creatorsAddresses?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  creatorsProfiles?: Maybe<Array<Maybe<IProfile>>>;
  description?: Maybe<Scalars['String']['output']>;
  id?: Maybe<Scalars['String']['output']>;
  latestPriceAmount?: Maybe<Scalars['Float']['output']>;
  latestPriceBlockHeight?: Maybe<Scalars['Long']['output']>;
  latestPriceCurrency?: Maybe<Scalars['String']['output']>;
  likes?: Maybe<Scalars['Int']['output']>;
  markets?: Maybe<Array<Maybe<IAssetMarket>>>;
  medias?: Maybe<Array<Maybe<IMedia>>>;
  name?: Maybe<Scalars['String']['output']>;
  originalUrls?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  ownersAddresses?: Maybe<Array<Maybe<Scalars['String']['output']>>>;
  ownersProfiles?: Maybe<Array<Maybe<IProfile>>>;
  rank?: Maybe<Scalars['Float']['output']>;
  tokenId?: Maybe<Scalars['String']['output']>;
  totalVolumes?: Maybe<Array<Maybe<ICurrencyAmountPair>>>;
  trueRank?: Maybe<Scalars['Float']['output']>;
  views?: Maybe<Scalars['Int']['output']>;
  visible?: Maybe<Scalars['Boolean']['output']>;
};

export type IAssetMarket = {
  marketDomain?: Maybe<Scalars['String']['output']>;
  marketId?: Maybe<Scalars['String']['output']>;
  marketName?: Maybe<Scalars['String']['output']>;
  marketUrl?: Maybe<Scalars['String']['output']>;
};

export type IAttribute = {
  name?: Maybe<Scalars['String']['output']>;
  value?: Maybe<Scalars['String']['output']>;
};

export type ICurrencyAmountPair = {
  amount?: Maybe<Scalars['Float']['output']>;
  currency?: Maybe<Scalars['String']['output']>;
};

export type IDynamicAssetData = {
  assetId: Scalars['String']['output'];
  isLikedByUser?: Maybe<Scalars['Boolean']['output']>;
  likesNum?: Maybe<Scalars['Int']['output']>;
  medias?: Maybe<Array<Maybe<IMedia>>>;
};

export type IMedia = {
  cover?: Maybe<Scalars['Boolean']['output']>;
  fileSize?: Maybe<Scalars['Long']['output']>;
  hidden?: Maybe<Scalars['Boolean']['output']>;
  mimeType?: Maybe<Scalars['String']['output']>;
  nsfw?: Maybe<Scalars['Int']['output']>;
  originalMime?: Maybe<Scalars['String']['output']>;
  originalUrl?: Maybe<Scalars['String']['output']>;
  previewUrl?: Maybe<Scalars['String']['output']>;
  sizeRatio?: Maybe<Scalars['Float']['output']>;
  url?: Maybe<Scalars['String']['output']>;
};

export type IMutation = {
  dislikeAsset: Scalars['Boolean']['output'];
  likeAsset: Scalars['Boolean']['output'];
  setDummy: Scalars['String']['output'];
};


export type IMutationDislikeAssetArgs = {
  assetId: Scalars['String']['input'];
};


export type IMutationLikeAssetArgs = {
  assetId: Scalars['String']['input'];
};

export type IProfile = {
  about?: Maybe<Scalars['String']['output']>;
  createdAt?: Maybe<Scalars['Long']['output']>;
  deleted?: Maybe<Scalars['Boolean']['output']>;
  deletedAt?: Maybe<Scalars['Long']['output']>;
  followers?: Maybe<Scalars['Int']['output']>;
  followings?: Maybe<Scalars['Int']['output']>;
  userId: Scalars['ID']['output'];
  username?: Maybe<Scalars['String']['output']>;
  userpic?: Maybe<Scalars['String']['output']>;
  views?: Maybe<Scalars['Int']['output']>;
  visible?: Maybe<Scalars['Boolean']['output']>;
};

export type IQuery = {
  fetchAssetByBlockchain: IAsset;
  fetchAssets: Array<Maybe<IAsset>>;
  fetchDynamicAssetData: IDynamicAssetData;
  fetchDynamicAssetsData: Array<Maybe<IDynamicAssetData>>;
  getDummy: Scalars['String']['output'];
};


export type IQueryFetchAssetByBlockchainArgs = {
  address?: InputMaybe<Scalars['String']['input']>;
  blockchain: Scalars['String']['input'];
  elrondId?: InputMaybe<Scalars['String']['input']>;
  tokenId?: InputMaybe<Scalars['String']['input']>;
};


export type IQueryFetchAssetsArgs = {
  assetIds: Array<Scalars['String']['input']>;
};


export type IQueryFetchDynamicAssetDataArgs = {
  assetId: Scalars['String']['input'];
};


export type IQueryFetchDynamicAssetsDataArgs = {
  assetIds: Array<Scalars['String']['input']>;
};



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>;
  AssetMarket: ResolverTypeWrapper<IAssetMarket>;
  Attribute: ResolverTypeWrapper<IAttribute>;
  Boolean: ResolverTypeWrapper<Scalars['Boolean']['output']>;
  CurrencyAmountPair: ResolverTypeWrapper<ICurrencyAmountPair>;
  DynamicAssetData: ResolverTypeWrapper<IDynamicAssetData>;
  Float: ResolverTypeWrapper<Scalars['Float']['output']>;
  ID: ResolverTypeWrapper<Scalars['ID']['output']>;
  Int: ResolverTypeWrapper<Scalars['Int']['output']>;
  Long: ResolverTypeWrapper<Scalars['Long']['output']>;
  Media: ResolverTypeWrapper<IMedia>;
  Mutation: ResolverTypeWrapper<{}>;
  Profile: ResolverTypeWrapper<IProfile>;
  Query: ResolverTypeWrapper<{}>;
  String: ResolverTypeWrapper<Scalars['String']['output']>;
};

/** Mapping between all available schema types and the resolvers parents */
export type IResolversParentTypes = {
  Asset: IAsset;
  AssetMarket: IAssetMarket;
  Attribute: IAttribute;
  Boolean: Scalars['Boolean']['output'];
  CurrencyAmountPair: ICurrencyAmountPair;
  DynamicAssetData: IDynamicAssetData;
  Float: Scalars['Float']['output'];
  ID: Scalars['ID']['output'];
  Int: Scalars['Int']['output'];
  Long: Scalars['Long']['output'];
  Media: IMedia;
  Mutation: {};
  Profile: IProfile;
  Query: {};
  String: Scalars['String']['output'];
};

export type IAssetResolvers<ContextType = any, ParentType extends IResolversParentTypes['Asset'] = IResolversParentTypes['Asset']> = {
  address?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  assetId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
  attributes?: Resolver<Maybe<Array<Maybe<IResolversTypes['Attribute']>>>, ParentType, ContextType>;
  blockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  blockTimestamp?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  blockchain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  blockchainLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  blurred?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  category?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  categoryLabel?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  chainId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  collection?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  collectionId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  collectionMedias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
  collectionOriginalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  collectionTitle?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  creatorsAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  creatorsProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
  description?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  id?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  latestPriceAmount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  latestPriceBlockHeight?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  latestPriceCurrency?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  likes?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  markets?: Resolver<Maybe<Array<Maybe<IResolversTypes['AssetMarket']>>>, ParentType, ContextType>;
  medias?: Resolver<Maybe<Array<Maybe<IResolversTypes['Media']>>>, ParentType, ContextType>;
  name?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  originalUrls?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  ownersAddresses?: Resolver<Maybe<Array<Maybe<IResolversTypes['String']>>>, ParentType, ContextType>;
  ownersProfiles?: Resolver<Maybe<Array<Maybe<IResolversTypes['Profile']>>>, ParentType, ContextType>;
  rank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  tokenId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  totalVolumes?: Resolver<Maybe<Array<Maybe<IResolversTypes['CurrencyAmountPair']>>>, ParentType, ContextType>;
  trueRank?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IAssetMarketResolvers<ContextType = any, ParentType extends IResolversParentTypes['AssetMarket'] = IResolversParentTypes['AssetMarket']> = {
  marketDomain?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  marketId?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  marketName?: 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']> = {
  amount?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  currency?: Resolver<Maybe<IResolversTypes['String']>, 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']> = {
  cover?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  fileSize?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  hidden?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  mimeType?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  nsfw?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  originalMime?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  originalUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  previewUrl?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  sizeRatio?: Resolver<Maybe<IResolversTypes['Float']>, ParentType, ContextType>;
  url?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IMutationResolvers<ContextType = any, ParentType extends IResolversParentTypes['Mutation'] = IResolversParentTypes['Mutation']> = {
  dislikeAsset?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationDislikeAssetArgs, 'assetId'>>;
  likeAsset?: Resolver<IResolversTypes['Boolean'], ParentType, ContextType, RequireFields<IMutationLikeAssetArgs, 'assetId'>>;
  setDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};

export type IProfileResolvers<ContextType = any, ParentType extends IResolversParentTypes['Profile'] = IResolversParentTypes['Profile']> = {
  about?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  createdAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  deleted?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  deletedAt?: Resolver<Maybe<IResolversTypes['Long']>, ParentType, ContextType>;
  followers?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  followings?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  userId?: Resolver<IResolversTypes['ID'], ParentType, ContextType>;
  username?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  userpic?: Resolver<Maybe<IResolversTypes['String']>, ParentType, ContextType>;
  views?: Resolver<Maybe<IResolversTypes['Int']>, ParentType, ContextType>;
  visible?: Resolver<Maybe<IResolversTypes['Boolean']>, ParentType, ContextType>;
  __isTypeOf?: IsTypeOfResolverFn<ParentType, ContextType>;
};

export type IQueryResolvers<ContextType = any, ParentType extends IResolversParentTypes['Query'] = IResolversParentTypes['Query']> = {
  fetchAssetByBlockchain?: Resolver<IResolversTypes['Asset'], ParentType, ContextType, RequireFields<IQueryFetchAssetByBlockchainArgs, 'blockchain'>>;
  fetchAssets?: Resolver<Array<Maybe<IResolversTypes['Asset']>>, ParentType, ContextType, RequireFields<IQueryFetchAssetsArgs, 'assetIds'>>;
  fetchDynamicAssetData?: Resolver<IResolversTypes['DynamicAssetData'], ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetDataArgs, 'assetId'>>;
  fetchDynamicAssetsData?: Resolver<Array<Maybe<IResolversTypes['DynamicAssetData']>>, ParentType, ContextType, RequireFields<IQueryFetchDynamicAssetsDataArgs, 'assetIds'>>;
  getDummy?: Resolver<IResolversTypes['String'], ParentType, ContextType>;
};

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 IFetchAssetByBlockchainQueryVariables = Exact<{
  blockchain: Scalars['String']['input'];
  address?: InputMaybe<Scalars['String']['input']>;
  tokenId?: InputMaybe<Scalars['String']['input']>;
  elrondId?: InputMaybe<Scalars['String']['input']>;
}>;


export type IFetchAssetByBlockchainQuery = { fetchAssetByBlockchain: { assetId: string } };


export const FetchAssetByBlockchainDocument = gql`
    query fetchAssetByBlockchain($blockchain: String!, $address: String, $tokenId: String, $elrondId: String) {
  fetchAssetByBlockchain(
    blockchain: $blockchain
    address: $address
    tokenId: $tokenId
    elrondId: $elrondId
  ) {
    assetId
  }
}
    `;

/**
 * __useFetchAssetByBlockchainQuery__
 *
 * To run a query within a React component, call `useFetchAssetByBlockchainQuery` and pass it any options that fit your needs.
 * When your component renders, `useFetchAssetByBlockchainQuery` 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 } = useFetchAssetByBlockchainQuery({
 *   variables: {
 *      blockchain: // value for 'blockchain'
 *      address: // value for 'address'
 *      tokenId: // value for 'tokenId'
 *      elrondId: // value for 'elrondId'
 *   },
 * });
 */
export function useFetchAssetByBlockchainQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables> & ({ variables: IFetchAssetByBlockchainQueryVariables; skip?: boolean; } | { skip: boolean; }) ) {
        const options = {...defaultOptions, ...baseOptions}
        return Apollo.useQuery<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>(FetchAssetByBlockchainDocument, options);
      }
export function useFetchAssetByBlockchainLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>) {
          const options = {...defaultOptions, ...baseOptions}
          return Apollo.useLazyQuery<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>(FetchAssetByBlockchainDocument, options);
        }
export function useFetchAssetByBlockchainSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>) {
          const options = baseOptions === Apollo.skipToken ? baseOptions : {...defaultOptions, ...baseOptions}
          return Apollo.useSuspenseQuery<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>(FetchAssetByBlockchainDocument, options);
        }
export type FetchAssetByBlockchainQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainQuery>;
export type FetchAssetByBlockchainLazyQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainLazyQuery>;
export type FetchAssetByBlockchainSuspenseQueryHookResult = ReturnType<typeof useFetchAssetByBlockchainSuspenseQuery>;
export type FetchAssetByBlockchainQueryResult = Apollo.QueryResult<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>;