@ludo.ninja/api-server-assets/build/schema.d.ts

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!

import { GraphQLResolveInfo, GraphQLScalarType, GraphQLScalarTypeConfig } from 'graphql';
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]>;
};
/** 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 declare const FetchAssetByBlockchainDocument: Apollo.DocumentNode;
/**
 * __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 declare function useFetchAssetByBlockchainQuery(baseOptions: Apollo.QueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables> & ({
    variables: IFetchAssetByBlockchainQueryVariables;
    skip?: boolean;
} | {
    skip: boolean;
})): Apollo.InteropQueryResult<IFetchAssetByBlockchainQuery, Exact<{
    blockchain: Scalars["String"]["input"];
    address?: InputMaybe<Scalars["String"]["input"]>;
    tokenId?: InputMaybe<Scalars["String"]["input"]>;
    elrondId?: InputMaybe<Scalars["String"]["input"]>;
}>>;
export declare function useFetchAssetByBlockchainLazyQuery(baseOptions?: Apollo.LazyQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>): Apollo.LazyQueryResultTuple<IFetchAssetByBlockchainQuery, Exact<{
    blockchain: Scalars["String"]["input"];
    address?: InputMaybe<Scalars["String"]["input"]>;
    tokenId?: InputMaybe<Scalars["String"]["input"]>;
    elrondId?: InputMaybe<Scalars["String"]["input"]>;
}>>;
export declare function useFetchAssetByBlockchainSuspenseQuery(baseOptions?: Apollo.SkipToken | Apollo.SuspenseQueryHookOptions<IFetchAssetByBlockchainQuery, IFetchAssetByBlockchainQueryVariables>): Apollo.UseSuspenseQueryResult<IFetchAssetByBlockchainQuery, Exact<{
    blockchain: Scalars["String"]["input"];
    address?: InputMaybe<Scalars["String"]["input"]>;
    tokenId?: InputMaybe<Scalars["String"]["input"]>;
    elrondId?: InputMaybe<Scalars["String"]["input"]>;
}>>;
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>;