import React, { FC } from 'react';
import { ApolloClient, NormalizedCacheObject, ErrorPolicy, DefaultContext, FetchPolicy } from '@apollo/client';

interface CoreServiceProviderProps {
    children: React.ReactNode;
    client?: ApolloClient<NormalizedCacheObject>;
    uri?: string;
    token?: string;
}
type SessionStatus = 'Active' | 'Expired';
declare const CoreServiceProvider: FC<CoreServiceProviderProps>;

interface Response<T> {
    data?: T;
    networkStatus?: number;
}

interface QueryOptions {
    errorPolicy?: ErrorPolicy;
    context?: DefaultContext;
    fetchPolicy?: FetchPolicy;
    pollInterval?: number;
    notifyOnNetworkStatusChange?: boolean;
    returnPartialData?: boolean;
    partialRefetch?: boolean;
    canonizeResults?: boolean;
}
interface MutationOptions {
    errorPolicy?: ErrorPolicy;
    awaitRefetchQueries?: boolean;
}

interface MarketplaceUser {
    id: string;
    avatar: string;
    username: string;
}
interface BidsItemData {
    id: string;
    marketplaceAuctionLotId: string;
    currentBid: number;
    maximumBid: number;
    userId: string;
    amount: number;
    isCurrent: number;
    createdAt: Date;
    deletedAt: Date;
    marketplaceUser: MarketplaceUser;
    isMine: number;
    buyersPremium: number;
    overheadPremium: number;
    finalPrice: number;
    txHash: string;
    tax: number;
    walletAddress: string;
    txStatus: string;
}
declare enum MarketplaceCollectionItemStatus {
    Active = "Active",
    Completed = "Completed",
    Hidden = "Hidden",
    Preview = "Preview"
}

interface MetaData$4 {
    name: string;
    description: string;
    image: string;
    animationURL?: string;
    openSeaImageURL?: string;
    animationFormat?: string;
    animationType?: string;
}
interface Network {
    id: string;
    name: string;
    chainID: number;
}
interface NFTAttributes {
    traitType: string;
    traitValue: string;
}
interface NFTDetail {
    contractAddress: string;
    tokenId: string;
    tokenType: string;
    network: Network;
    metadata: MetaData$4;
    nftTokenId: string;
    nftAttributes: NFTAttributes[];
}
interface DetailsInfo {
    id: string;
    totalUnits: number;
    perWalletLimit: number;
    startDate: string;
    endDate: string;
    claimingType: string;
    totalAvailableUnits: number;
}
interface NetworkDetails {
    id: string;
    name: string;
    chainID: number;
    isTestnet: boolean;
}
interface CollectionDetails {
    tokenType: string;
    network: NetworkDetails;
}
interface CollectionItemByClaimCode {
    id: string;
    name: string;
    status: string;
    slug: string;
    collectionId: string;
    asset?: {
        currentVersion: {
            cdnUrl: string;
        };
    };
    collectionDetails?: CollectionDetails;
    deliveryMethod?: string;
    description?: string;
    saleType: string;
    isRedeemedCode: boolean;
    isOnchain: boolean;
    NFTDetails: NFTDetail[];
    details: DetailsInfo;
}
interface AuctionData {
    collectionItemById?: {
        id: string;
        name: string;
        artist: {
            artistName: string;
        };
        status: MarketplaceCollectionItemStatus;
        marketplaceTokenId: string;
        collectionSlug: string;
        slug: string;
        collectionId: string;
        saleType: string;
        paymentCurrencyId: string;
        isOnchain: boolean;
        NFTDetails: {
            contractAddress: string;
            tokenId: number;
            tokenType: string;
            network: Network;
            networkID: string;
            owner: string;
            metadata: MetaData$4;
            nftAttributes: NFTAttributes[];
            artist: {
                id: string;
                description: string;
                artistName: string;
            };
            nftTokenId: string;
        };
        isReserved: boolean;
        details: {
            totalUnits: number;
            perWalletLimit: number;
            claimingType: string;
            totalAvailableUnits: number;
            id: string;
            startingBid: string;
            startDate: string;
            endDate: string;
            currentBid: {
                userId: string;
                maximumBid: number;
                currentBid: number;
                isMine: boolean;
                walletAddress: string;
                marketplaceUser: MarketplaceUser;
            };
            myBid: {
                currentBid: number;
                maximumBid: number;
            };
            bids: BidsItemData[];
            marketplaceAuctionOnChainSettings: {
                endTransactionHash: string;
            };
        };
    };
}
type AuctionByClaimCodeData = {
    collectionItemByClaimCode?: CollectionItemByClaimCode;
};

interface OnChainBidResponse {
    verifyOnchainBid?: {
        orgID: string;
        networkID: string;
        amount: number;
        tax: number;
        onChainAuctionContractAddress: string;
        commissionFee: number;
        platformFee: number;
    };
}

interface MarketplaceAuctionLot {
    id: string;
    lotNumber: number;
    marketplaceCollectionItemId: string;
    startingBid: number;
    reservePrice: number;
    reserveMet: number;
    previewDate: Date;
    startDate: Date;
    endDate: Date;
    status: MarketplaceCollectionItemStatus;
    currentBid: BidsItemData;
    myBid: BidsItemData;
    isOnchainAuction: number;
}

interface ConfirmOnChainBidResponse {
    confirmOnchainBid?: {
        amount?: number;
        tax: number;
        isCurrent?: boolean;
    };
}

interface CreateMarketplaceAuctionBidResponse {
    createMarketplaceAuctionBid?: {
        id: string;
        marketplaceAuctionLotId: string;
        transactionHash: string;
        amount: number;
    };
}

interface AuctionDetailsParam {
    id: string;
}
interface AuctionDetailsByClaimCodeParam {
    claimCode: string;
}
interface VerifyOnChainBidParam {
    lotID: string;
    orgID: string;
    walletAddress: string;
    amount: number;
}
interface ConfirmOnChainBidParam {
    lotID: string;
    orgID: string;
    walletAddress: string;
    amount: number;
    tax: number;
    txhash: string;
    commissionFee: number;
    platformFee: number;
}
interface CreateMarketplaceAuctionBidParam {
    marketplaceAuctionLotId: string;
    amount: number;
}

interface AuctionService {
    /**
     * Returns auction Details
     *
     * @remarks
     * This method is part of auction module, fetch auction details
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link AuctionData} auction data
     *
     */
    auctionDetails: (param: AuctionDetailsParam, options?: QueryOptions) => Promise<Response<AuctionData>>;
    /**
    * Returns auction by claim code Details
    *
    * @remarks
    * This method is part of auction module, fetch auction by claim code details
    *
    * @param param - param {@link OnChainBidResponse}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link AuctionByClaimCodeData} auction by claim code data
    *
    */
    auctionDetailsByClaimCode: (param: AuctionDetailsByClaimCodeParam, options?: QueryOptions) => Promise<Response<AuctionByClaimCodeData>>;
    /**
     * Returns On ChainBid Details
     *
     * @remarks
     * This method is part of auction module, verify on chain bid
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link OnChainBidResponse} On ChainBid data
     *
     */
    verifyOnChainBid: (param: VerifyOnChainBidParam, options?: QueryOptions) => Promise<Response<OnChainBidResponse>>;
    /**
     * Returns ConfirmOnChainBidResponse confirm On ChainBid
     *
     * @remarks
     * This method is part of auction module, confirm on chain bid
     *
     * @param param - param {@link ConfirmOnChainBidParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link ConfirmOnChainBidResponse} BidsItem Data
     *
     */
    confirmOnChainBid: (param: ConfirmOnChainBidParam, options?: QueryOptions) => Promise<Response<ConfirmOnChainBidResponse>>;
    /**
   * Returns CreateMarketplaceAuctionBidResponse on create marketplace auction bid
   *
   * @remarks
   * This method is part of auction module, create marketplace auction bid
   *
   * @param param - param {@link CreateMarketplaceAuctionBidParam}
   * @param options - graphql fetch query options {@link QueryOptions}
   * @returns {@link CreateMarketplaceAuctionBidResponse} BidsItem Data
   *
   */
    createMarketplaceAuctionBid: (param: CreateMarketplaceAuctionBidParam, options?: QueryOptions) => Promise<Response<CreateMarketplaceAuctionBidResponse>>;
}

/**
 * Returns auction & bid service
 *
 * @remarks
 * This method is part of auction service
 *
 * @returns {@link AuctionService} auction details service
 *
*/
declare const useAuction: () => AuctionService;

interface RedeemClaimableCodeData {
    redeemClaimableCode?: {
        success?: boolean;
    };
}
interface RedeemEarnableItemData {
    redeemEarnableItem: {
        redeemInitiated: boolean;
        invoiceID: string;
        claimVoucher?: {
            voucherID: string;
            claimExtension: string;
            tokenUri: string;
            claimer: string;
            expiryTime: string;
            signature: string;
        };
    };
}
interface RedeemEarnableCodeData {
    redeemEarnableCode: {
        redeemInitiated: boolean;
        invoiceID: string;
    };
}
interface MetaData$3 {
    name: string;
    description: string;
    image: string;
}
interface NFTDetails {
    title?: string;
    description?: string;
    onChainId?: string;
    contractAddress?: string;
    balance?: string;
    metadataJSON?: string;
    networkId?: string;
    networkChainID?: number;
    tokenMetadata?: MetaData$3;
}
interface InvoiceItems {
    collectionTitle: string;
    collectionItemTitle: string;
    collectionItemImage: string;
    collectionItemDescription: string;
    transactionHash: string;
    transactionStatus: string;
    nftDetails: NFTDetails[];
}
interface GetInvoiceDetailsData {
    invoiceID: string;
    invoiceNumber: number;
    internalUserID: string;
    userName: string;
    status: string;
    items: InvoiceItems[];
}
interface GetClaimInvoiceDetailData {
    getInvoiceDetails: GetInvoiceDetailsData;
}
interface GetContractDetailsData {
    getContractDetails: {
        id: string;
        networkID: string;
        contractName: string;
        contractAddress: string;
        version: string;
        contractABIFileURL: string;
    };
}
interface CompleteOnchainClaimData {
    completeOnchainClaim: boolean;
}
interface CanRedeemClaimableData {
    canRedeemClaimableItem: boolean;
}
interface CanRedeemClaimableV2Data {
    canRedeemClaimableItemV2: {
        canRedeem: boolean;
        latestInvoice: {
            invoiceID: string;
            status: string;
            onChainTokenId: number;
            invoiceCreatedAt: string;
        };
    };
}

interface RedeemClaimableCodeParam {
    code: string;
    destAddr: string;
}
interface GateInput {
    ruleId: string;
    contractAddress: string;
    tokenId: string;
    ownerWallet: string;
}
interface RedeemEarnableItemParam {
    claimableItemId: string;
    destAddr?: string;
    gating?: GateInput;
}
interface GetClaimInvoiceDetailParam {
    invoiceID: string;
}
interface RedeemEarnableCodeParam {
    code: string;
    destAddr: string;
}
interface GetContractDetailsParam {
    orgId: string;
    networkId: string;
    contractType: string;
}
interface CompleteOnchainClaimParam {
    invoiceId: string;
    txHash: string;
}
interface CanRedeemClaimableParam {
    claimableItemID: string;
    destAddr: string;
}

interface ClaimService {
    /**
     * Returns the redeem claim code
     *
     * @remarks
     * This method is part of redeem claim code
     *
     * @param param - redeem claim code {@link RedeemClaimableCodeParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link RedeemClaimableCodeData} claim code status (success)
     *
     */
    redeemClaimableCode: (param: RedeemClaimableCodeParam, options?: QueryOptions) => Promise<Response<RedeemClaimableCodeData>>;
    /**
   * Returns the redeem claim code
   *
   * @remarks
   * This method is part of redeem claim code
   *
   * @param param - redeem claim code {@link RedeemEarnableCodeParam}
   * @param options - graphql fetch query options {@link QueryOptions}
   * @returns {@link RedeemEarnableCodeData} claim code status (success)
   *
   */
    redeemEarnableCode: (param: RedeemEarnableCodeParam, options?: QueryOptions) => Promise<Response<RedeemEarnableCodeData>>;
    /**
     * Returns the status of Redeem Initiated
     *
     * @remarks
     * This method is part of redeem earnable item
     *
     * @param param - redeem earnable item {@link RedeemEarnableItemParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link RedeemEarnableItemData} redeem earnable item status
     *
     */
    redeemEarnableItem: (param: RedeemEarnableItemParam, options?: MutationOptions) => Promise<Response<RedeemEarnableItemData>>;
    /**
    * Returns Invoice detail
    *
    * @remarks
    * This method is part of getting invoice detail
    *
    * @param param - invoice id {@link GetClaimInvoiceDetailParam}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link GetClaimInvoiceDetailData} invoice detail
    *
    */
    getInvoiceDetails: (param: GetClaimInvoiceDetailParam, options?: QueryOptions) => Promise<Response<GetClaimInvoiceDetailData>>;
    /**
    * Returns contract details
    *
    * @remarks
    * This method is part of getting contract detail
    *
    * @param param - contract param {@link GetContractDetailsParam}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link GetContractDetailsData} contract details
    *
    */
    getContractDetails: (param: GetContractDetailsParam, options?: QueryOptions) => Promise<Response<GetContractDetailsData>>;
    /**
     * Returns the boolean
     *
     * @remarks
     * This method is part of complete onchain claim
     *
     * @param param - complete onchain claim {@link CompleteOnchainClaimParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CompleteOnchainClaimData} complete onchain claim status
     *
     */
    completeOnchainClaim: (param: CompleteOnchainClaimParam, options?: MutationOptions) => Promise<Response<CompleteOnchainClaimData>>;
    /**
      * Returns the boolean
      *
      * @remarks
      * This method is part of claim service
      *
      * @param param - param {@link CanRedeemClaimableParam}
      * @param options - graphql fetch query options {@link QueryOptions}
      * @returns {@link CanRedeemClaimableData} redeem data
      *
      */
    canRedeemClaimableItem: (param: CanRedeemClaimableParam, options?: QueryOptions) => Promise<Response<CanRedeemClaimableData>>;
    /**
      * Returns the invoice object
      *
      * @remarks
      * This method is part of claim service
      *
      * @param param - param {@link CanRedeemClaimableParam}
      * @param options - graphql fetch query options {@link QueryOptions}
      * @returns {@link CanRedeemClaimableV2Data} redeem data
      *
      */
    canRedeemClaimableItemV2: (param: CanRedeemClaimableParam, options?: QueryOptions) => Promise<Response<CanRedeemClaimableV2Data>>;
}

/**
 * Returns redeem code service
 *
 * @remarks
 * This method is part of the web3 claim token
 *
 * @returns {@link ClaimService} redeem code service
 *
*/
declare const useClaims: () => ClaimService;

declare enum CryptoCurrencyCode {
    ETH = "ETH",
    MATIC = "MATIC",
    WETH = "WETH",
    WMATIC = "WMATIC",
    AR = "AR",
    EUR = "EUR",
    VIN = "VIN",
    SOL = "SOL"
}
declare enum CurrencyCode {
    USD = "USD",
    EUR = "EUR",
    ETH = "ETH",
    MATIC = "MATIC",
    WETH = "WETH",
    WMATIC = "WMATIC",
    AR = "AR",
    BTC = "BTC",
    USDC = "USDC",
    USDT = "USDT",
    SOL = "SOL",
    VIN = "VIN"
}
interface GetUSDConversionParam {
    cryptoCurrencyCode: CryptoCurrencyCode;
}
interface GetSupportedCurrenciesParam {
    nftTokenId: string;
    orgId: string;
}
interface GetConversionRateParam {
    toCurrency: CurrencyCode;
    fromCurrecny: CurrencyCode;
}

interface USDConversionData {
    getUSDPrice?: {
        amount: string;
        currency: string;
        base: string;
    };
}
interface SupportedCurrencyData {
    id: string;
    name: string;
    networkId: string;
    symbol: string;
    contractAddress: string;
    secondaryMarketplaceContractAddress: string;
    network: {
        id: string;
        name: string;
        chainID: number;
        wethAddress: string;
        paymentCurrency: string;
    };
}
interface GetSupportedCurrenciesData {
    getSupportedCurrencies?: SupportedCurrencyData[];
}
interface GetConversionRateData {
    getConversionRate?: {
        rate: number;
        base: CurrencyCode;
        currency: CurrencyCode;
    };
}

interface ConversionService {
    /**
    * Returns the usd conversion from crypto
    *
    * @remarks
    * This method is part of currency conversion
    *
    * @param param - param {@link GetUSDConversionParam}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link USDConversionData} claim code status (success)
    *
    */
    getUSDConversion: (param: GetUSDConversionParam, options?: QueryOptions) => Promise<Response<USDConversionData>>;
    /**
     * Returns the conversion of any currency
     *
     * @remarks
     * This method is part of currency conversion
     *
     * @param param - param {@link GetConversionRateParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetConversionRateData} conversion currency response
     *
     */
    getConversionRate: (param: GetConversionRateParam, options?: QueryOptions) => Promise<Response<GetConversionRateData>>;
    /**
     * Returns the supported currency list
     *
     * @remarks
     * This method is part of currency conversion
     *
     * @param param - param {@link GetSupportedCurrenciesParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetSupportedCurrenciesData} supported currency data
     *
     */
    getSupportedCurrency: (param: GetSupportedCurrenciesParam, options?: QueryOptions) => Promise<Response<GetSupportedCurrenciesData>>;
}

/**
 * Returns the currency conversion service
 *
 * @remarks
 * This method is part of the currency conversion service
 *
 * @returns {@link ConversionService} signature service
 *
*/
declare const useConversion: () => ConversionService;

interface LoginWithSignatureData {
    loginWithSignature?: {
        token?: string;
        tokenType?: string;
        __typename?: string;
    };
}
interface GetSignatureData {
    getSignatureMessage?: string;
}
interface SignUpWithSignatureData {
    signUpWithSignature?: {
        token?: string;
        tokenType?: string;
        jwtRefreshToken?: string;
    };
}

interface GetSignatureParam {
    orgId: string;
    walletAddress: string;
    networkID: string;
}
interface LoginWithSignatureParam {
    chainId: number;
    challenge: string;
    orgId: string;
    signature: string;
    signer: string;
}
interface SignUpWithSignatureParam {
    chainId: number;
    challenge: string;
    orgId: string;
    signature: string;
    signer: string;
    firstName: string;
    lastName: string;
    email: string;
}

interface SignatureService {
    /**
     * Returns the signature message
     *
     * @remarks
     * This method is part of the web3 signature message
     *
     * @param param - param {@link GetSignatureParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetSignatureData} signature data
     *
     */
    getSignatureMessage: (param: GetSignatureParam, options?: QueryOptions) => Promise<Response<GetSignatureData>>;
    /**
     * Returns the login with signature
     *
     * @remarks
     * This method is part of the web3 login signature message & signer
     *
     * @param param - login with signature message {@link GetSignatureParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link LoginWithSignatureData} signature data
     *
     */
    loginWithSignature: (param: LoginWithSignatureParam, options?: MutationOptions) => Promise<Response<LoginWithSignatureData>>;
    /**
     * Returns the signUp with signature
     *
     * @remarks
     * This method is part of the web3 signUp signature message & signer
     *
     * @param param - SignUp with Signature Param {@link SignUpWithSignatureParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link SignUpWithSignatureData} signUp with signature data
     *
     */
    signUpWithSignature: (param: SignUpWithSignatureParam, options?: MutationOptions) => Promise<Response<SignUpWithSignatureData>>;
}

/**
 * Returns the signature message service & login
 *
 * @remarks
 * This method is part of the web3 signature message
 *
 * @returns {@link SignatureService} signature service
 *
*/
declare const useSignature: () => SignatureService;

declare enum KycStatusEnum {
    none = "None",
    pending = "Pending",
    level1 = "Level1",
    level2 = "Level2",
    clear = "Clear",
    failed1 = "Failed1",
    failed2 = "Failed2"
}
interface GetUserData {
    me?: {
        id: string;
        user?: {
            name: string;
            username: string;
            email: string;
        };
        userOrgs?: {
            id: string;
            role: string;
            organizationId: string;
            organization?: {
                purchaseLimitWithoutKYC: number;
            };
            externalUserId: string;
            kycStatus: KycStatusEnum;
            w8Form: boolean;
            isBlacklisted: boolean;
            bidAllowed: boolean;
            username: string;
            avatar: string;
            profilePic: string;
            reason: string;
            settings: string;
        }[];
    };
}
interface UpdateUserOrgSettingsData {
    updateUserOrgSettings: {
        id: string;
        username: string;
        avatar: string;
    };
}

interface GetUserParam {
    orgId: string;
}
interface UpdateUserOrgSettingsParam {
    userOrgId: string;
    username: string;
    avatar: string;
    settingsJson?: string;
    profilePic?: string;
}

interface UserService {
    /**
     * Returns user Details
     *
     * @remarks
     * This method is part of user module, fetch current user details
     *
     * @param param - param {@link GetUserParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetUserData} current user data
     *
     */
    getUser: (param: GetUserParam, options?: QueryOptions) => Promise<Response<GetUserData>>;
    /**
     * Returns updated user details
     *
     * @remarks
     * This method is part of user module, update user details
     *
     * @param param - param {@link UpdateUserOrgSettingsParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link UpdateUserOrgSettingsData} user org settings Data
     *
     */
    updateUserOrgSettings: (param: UpdateUserOrgSettingsParam, options?: QueryOptions) => Promise<Response<UpdateUserOrgSettingsData>>;
}

/**
 * Returns user service
 *
 * @remarks
 * This method is part of user service
 *
 * @returns {@link UserService} user details service
 *
 */
declare const useUser: () => UserService;

interface ApplicantData {
    id: string;
    firstName: string;
    lastName: string;
    email?: string;
    dob?: string;
    href?: string;
    idNumbers?: {
        type: string;
        value: string;
        stateCode: string;
    };
    address?: {
        flatNumber?: string;
        buildingNumber?: string;
        buildingName?: string;
        street?: string;
        subStreet?: string;
        town?: string;
        postcode?: string;
        country?: string;
        line1?: string;
        line2?: string;
        line3?: string;
        state?: string;
    };
}
interface GetApplicantData {
    getApplicant: ApplicantData;
}
interface CreateApplicantData {
    createApplicant: ApplicantData;
}
interface UpdateApplicantData {
    updateApplicant: ApplicantData;
}
interface GetSDKTokenData {
    getSDKToken: {
        token: string;
    };
}
interface CreateCheckData {
    createCheck: {
        id: string;
        success: string;
    };
}

interface InputParam {
    firstName: string;
    lastName: string;
    email?: string;
    dob?: string;
    address?: {
        flatNumber?: string;
        buildingNumber?: string;
        buildingName?: string;
        street?: string;
        subStreet?: string;
        town?: string;
        postcode: string;
        country: string;
        line1?: string;
        line2?: string;
        line3?: string;
        state?: string;
    };
}
interface CreateApplicantParam {
    orgID: string;
    input: InputParam;
}
interface UpdateApplicantParam {
    applicantID: string;
    input: InputParam;
}
interface GetApplicantParam {
    organizationID: string;
}
interface GetSDKTokenParam {
    applicantID: string;
    referrer: string;
}
interface CreateCheckParam {
    applicantID: string;
}

interface KYCService {
    /**
     * Returns applicant details
     *
     * @remarks
     * This method is part of KYC module, create applicant
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CreateApplicantData} applicant data
     *
     */
    createApplicant: (param: CreateApplicantParam, options?: QueryOptions) => Promise<Response<CreateApplicantData>>;
    /**
     * Returns applicant details
     *
     * @remarks
     * This method is part of KYC module, update applicant
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link UpdateApplicantData} applicant data
     *
     */
    updateApplicant: (param: UpdateApplicantParam, options?: QueryOptions) => Promise<Response<UpdateApplicantData>>;
    /**
     * Returns applicant details
     *
     * @remarks
     * This method is part of KYC module, fetch applicant details
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetApplicantData} applicant data
     *
     */
    getApplicant: (param: GetApplicantParam, options?: QueryOptions) => Promise<Response<GetApplicantData>>;
    /**
     * Returns token details
     *
     * @remarks
     * This method is part of KYC module, fetch SDK token details
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetSDKTokenData} token data
     *
     */
    getSDKToken: (param: GetSDKTokenParam, options?: QueryOptions) => Promise<Response<GetSDKTokenData>>;
    /**
     * Returns success response
     *
     * @remarks
     * This method is part of KYC module, create check
     *
     * @param param - param {@link OnChainBidResponse}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CreateCheckData} success response
     *
     */
    createCheck: (param: CreateCheckParam, options?: QueryOptions) => Promise<Response<CreateCheckData>>;
}

/**
 * Returns KYC service
 *
 * @remarks
 * This method is part of KYC service
 *
 * @returns {@link KYCService} KYC details service
 *
*/
declare const useKYC: () => KYCService;

interface NetworkData {
    id: string;
    name: string;
    chainID: number;
    isTestnet: boolean;
}
interface GetSupportedNetworksData {
    getSupportedNetworks: NetworkData[];
}
interface ConnectExternalWalletData {
    connectExternalWallet: boolean;
}
interface NFTPriceData {
    value: number;
    unit: string;
    type: string;
}
interface MetaData$2 {
    name: string;
    description: string;
    image: string;
    animationURL?: string;
    openSeaImageURL?: string;
    animationFormat?: string;
    animationType?: string;
    downloadVideo?: string;
    video: string;
}
declare enum TokenStatus$1 {
    NEW = "NEW",
    ENQUIRY_PENDING = "ENQUIRY_PENDING",
    OPEN_FOR_SALE = "OPEN_FOR_SALE",
    SALE_PENDING = "SALE_PENDING"
}
interface TokenData {
    contractAddress: string;
    id: string;
    network: string;
    networkID: string;
    tokenType: string;
    balance: string;
    title: string;
    description: string;
    tokenURI: string;
    timeLastUpdated: string;
    nftTokenId: string;
    mintedAt: string;
    status: TokenStatus$1;
    listedAt: string;
    editionNumber: number;
    mediaSourceURL: string;
    mediaSourceExtension: string;
    mediaSourceType: string;
    metadata: MetaData$2;
    contractName: string;
    artistName: string;
    price: {
        buyNowPrice: NFTPriceData[];
        lastPurchasedPrice: NFTPriceData[];
        makeOfferHighestPrice: NFTPriceData[];
        makeOfferLatestPrice: NFTPriceData[];
    };
    listedOrderInfo: {
        id: string;
        listedCurrency: {
            contractAddress: string;
        };
        price: NFTPriceData[];
    };
    owner?: string;
    latestOffer: {
        price: NFTPriceData[];
    };
    isBuyNowEnabled: boolean;
    isMakeOfferEnabled: boolean;
    isOfferExist: boolean;
}
interface RequestObjectData {
    networkID: string;
    prevPageKey: string;
    nextPageKey: string;
    count: number;
    totalCount: number;
}
interface GetActiveWalletsContentData {
    getActiveWalletsContent: {
        tokens?: TokenData[];
        requestObj?: RequestObjectData;
    };
}

interface GetSupportedNetworksParam {
    orgId: string;
    includeTestnets: boolean;
}
interface ConnectExternalWalletParam {
    signature: string;
    message: string;
    address: string;
    orgID: string;
    networkID: string;
}
declare enum ActiveWalletSort {
    RECENTLY_LISTED = "recently_listed",
    RECENTLY_MINTED = "recently_minted",
    INITIALLY_MINTED = "initially_minted",
    PRICE_LOW_TO_HIGH = "price_low_to_high",
    PRICE_HIGH_TO_LOW = "price_high_to_low",
    MOST_SAVED = "most_saved",
    PURCHASED_FROM_ORG = "purchased_from_org"
}
interface ActiveWalletFilter {
    search?: string;
    sort?: ActiveWalletSort;
}
declare enum CurrencyCodeFiat {
    USD = "USD",
    EUR = "EUR"
}
type InvoiceFilterInputData = {
    dropID?: string;
    listingID?: string;
};
interface GetActiveWalletsContentParam {
    walletAddress: string;
    networkId: string;
    orgID: string;
    filters?: ActiveWalletFilter;
    nextPageKey?: string;
    refreshCache?: boolean;
    currency?: CurrencyCodeFiat;
    nftContractAddress?: string[];
    itemFilter?: InvoiceFilterInputData;
}

interface ConnectWalletService {
    /**
    * Returns the active wallet data
    *
    * @remarks
    * This method is part of connect wallet
    *
    * @param param - param {@link GetActiveWalletsContentParam}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link GetActiveWalletsContentData} wallet data
    *
    */
    getActiveWalletsContent: (param: GetActiveWalletsContentParam, options?: QueryOptions) => Promise<Response<GetActiveWalletsContentData>>;
    /**
     * Returns the supported network list
     *
     * @remarks
     * This method is part of connect wallet
     *
     * @param param - param {@link GetSupportedNetworksParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetSupportedNetworksData} supported network data
     *
     */
    getSupportedNetworks: (param: GetSupportedNetworksParam, options?: QueryOptions) => Promise<Response<GetSupportedNetworksData>>;
    /**
     * Returns the boolean wallet connected or not
     *
     * @remarks
     * This method is part of connect wallet
     *
     * @param param - param {@link ConnectExternalWalletParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link ConnectExternalWalletData} get boolean
     *
     */
    connectExternalWallet: (param: ConnectExternalWalletParam, options?: QueryOptions) => Promise<Response<ConnectExternalWalletData>>;
}

/**
 * Returns the connect wallet service
 *
 * @remarks
 * This method is part of the connect wallet service
 *
 * @returns {@link ConnectWalletService} connect wallet service
 *
*/
declare const useConnectWallet: () => ConnectWalletService;

declare enum TokenType$2 {
    erc721 = "ERC721",
    erc1155 = "ERC1155"
}
interface CreateSignatureToListNFTForSaleParam {
    orgId: string;
    nftTokenId: string;
    tokenType: string;
    quantity: number;
    nftOwnerAddress: string;
    fixedPrice: number;
    paymentToken: string;
    currencyId: string;
}
interface SubmitProofOfApprovalParam {
    orgID: string;
    nftTokenId: string;
    signature: string;
    quantity?: number;
    fixedPrice?: number;
    paymentToken?: string;
    currencyId?: string;
    creatorFee?: number;
    listingReceipt?: string;
    currency?: CurrencyCodeFiat;
}
interface RemoveListingParam {
    nftTokenId: string;
    orgID: string;
    currency?: CurrencyCodeFiat;
    signature?: string;
}
interface InitiateRemoveListingParam {
    nftTokenId: string;
    orgId: string;
}
interface UpdateTokenListingParam {
    orgId: string;
    nftTokenId: string;
    fixedPrice: number;
    signature: string;
}
interface EditTokenListingParam {
    orgId: string;
    nftTokenId: string;
    fixedPrice: number;
}

declare enum NFTOrderType$1 {
    listing = "LISTING",
    offer = "OFFER"
}
interface bubbleGumListArgParams {
    price: number;
    isCnft: boolean;
    isVin: boolean;
    dataHash: string;
    creatorHash: string;
    nonce: number;
    index: number;
    root?: string;
    proof?: string[];
    isUpdate: boolean;
}
interface BubbleGumListParams {
    seller: string;
    sellerTokenAccount: string;
    mintAccount: string;
    systemProgram: string;
    tokenProgram: string;
    rent: string;
    bubblegumProgram: string;
    compressionProgram: string;
    treeAuthority: string;
    leafOwner: string;
    previousLeafDelegate: string;
    newLeafDelegate: string;
    logWrapper: string;
    merkleTree: string;
    listDiscriminator: number[];
    metadataId: string;
    listingReceipt: string;
    bubblegumListArg: bubbleGumListArgParams;
}
interface bubblegumMakeOfferArg {
    offerAmount: number;
    isCnft: boolean;
    isVin: boolean;
    expirationTime: number;
    nonce: number;
    index: number;
}
interface BubblegumMakeOfferParams {
    buyer: string;
    buyerTokenAccount: string;
    offerEscrow: string;
    mintAccount: string;
    metadataId: string;
    offer: string;
    systemProgram: string;
    tokenProgram: string;
    makeOfferDiscriminator: number[];
    seller?: string;
    bubblegumMakeOfferArg: bubblegumMakeOfferArg;
    totalActiveOfferAmount?: number;
}
interface CreateSignatureToListNFTForSaleData {
    createSignatureToListNFTForSale: {
        messageToSign: string;
        order: {
            id: string;
            nftTokenId: string;
            tokenContract: string;
            tokenId: string;
            tokenType: TokenType$2;
            quantity: number;
            nftOwnerAddress: string;
            fixedPrice: number;
            paymentToken: string;
            orderType: NFTOrderType$1;
        };
        isSigningRequired: boolean;
        isNonEVM: boolean;
        bubblegumListParams?: BubbleGumListParams;
        bubblegumMakeOfferParams?: BubblegumMakeOfferParams;
    };
}
interface SubmitProofOfApprovalData {
    submitProofOfApproval: string;
}
interface RemoveListingData {
    removeListing: string;
}
interface InitiateRemoveListingResponseData {
    seller: string;
    sellerTokenAccount: string;
    mintAccount: string;
    metadataId: string;
    systemProgram: string;
    tokenProgram: string;
    rent: string;
    bubblegumProgram: string;
    compressionProgram: string;
    treeAuthority: string;
    leafOwner: string;
    previousLeafDelegate: string;
    newLeafDelegate: string;
    logWrapper: string;
    merkleTree: string;
    listDiscriminator: number[];
    bubblegumListArg: bubbleGumListArgParams;
    listingReceipt: string;
}
interface InitiateRemoveListingData {
    initiateRemoveListing: InitiateRemoveListingResponseData;
}
interface UpdateTokenListingData {
    updateTokenListing: string;
}
interface EditTokenListingData {
    editTokenListing: BubbleGumListParams;
}

interface ListItemService {
    /**
     * Returns the signature message and order data
     *
     * @remarks
     * This method is part of list item service
     *
     * @param param - create signature for list item {@link CreateSignatureToListNFTForSaleParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CreateSignatureToListNFTForSaleData} signature message and order data
     *
     */
    createSignatureToListNFTForSale: (param: CreateSignatureToListNFTForSaleParam, options?: QueryOptions) => Promise<Response<CreateSignatureToListNFTForSaleData>>;
    /**
     * Returns string
     *
     * @remarks
     * This method is part of list item service
     *
     * @param param - submit listing {@link SubmitProofOfApprovalParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link SubmitProofOfApprovalData} success response
     *
     */
    submitProofOfApproval: (param: SubmitProofOfApprovalParam, options?: QueryOptions) => Promise<Response<SubmitProofOfApprovalData>>;
    /**
     * Returns string
     *
     * @remarks
     * This method is part of list item service
     *
     * @param param - remove listing {@link RemoveListingParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link RemoveListingData} success response
     *
     */
    removeListing: (param: RemoveListingParam, options?: QueryOptions) => Promise<Response<RemoveListingData>>;
    /**
   * Returns string
   *
   * @remarks
   * This method is part of list item service
   *
   * @param param - remove listing {@link InitiateRemoveListingParam}
   * @param options - graphql fetch query options {@link QueryOptions}
   * @returns {@link InitiateRemoveListingData} success response
   *
   */
    initiateRemoveListing: (param: InitiateRemoveListingParam, options?: QueryOptions) => Promise<Response<InitiateRemoveListingData>>;
    /**
     * Returns string
     *
     * @remarks
     * This method is part of list item service
     *
     * @param param - remove listing {@link UpdateTokenListingParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link UpdateTokenListingData} success response
     *
     */
    updateTokenListing: (param: UpdateTokenListingParam, options?: QueryOptions) => Promise<Response<UpdateTokenListingData>>;
    /**
     * Returns edit listing response
     *
     * @remarks
     * This method is part of list item service
     *
     * @param param - remove listing {@link EditTokenListingParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link EditTokenListingData} success response
     *
     */
    editTokenListing: (param: EditTokenListingParam, options?: QueryOptions) => Promise<Response<EditTokenListingData>>;
}

/**
 * Returns list item service
 *
 * @remarks
 * This method is part of the list item service
 *
 * @returns {@link ListItemService} list item service
 *
*/
declare const useListItem: () => ListItemService;

interface AddressData {
    street1: string;
    city: string;
    state: string;
    postalCode: string;
    country: string;
    currencyCode?: string;
}
interface GetTaxQuoteData {
    getTaxQuote: {
        verifiedAddress: AddressData;
        taxablePrice: number;
        totalTaxedPrice: number;
        totalTaxAmount: number;
    };
}
interface TaxResponse {
    cryptoTaxPrice: number;
    cryptoTotalPrice: number;
    USDUnitprice: number;
    taxPercentage: number;
}
interface EstimateTaxAndRoyaltyFeeData {
    estimateTaxAndRoyaltyFee?: {
        taxPercentage: number;
        royaltyFee: number;
        platformFee: number;
        commissionFee?: number;
        taxResponse?: TaxResponse;
    };
}

interface GetTaxQuoteParam {
    street1: string;
    city: string;
    state: string;
    postalCode: string;
    country: string;
    currencyCode?: string;
    orgID: string;
    taxablePrice: number;
}
declare enum TaxEstimateType {
    LIST_FOR_SALE = "ListForSale",
    BUY_NOW = "BuyNow",
    MAKE_OFFER = "MakeOffer",
    ACCEPT_OFFER = "AcceptOffer"
}
interface EstimateTaxAndRoyaltyFeeParam {
    orgId: string;
    orderId?: string;
    nftTokenId?: string;
    price?: number;
    estimateType: TaxEstimateType;
    country?: string;
    postalCode?: string;
    currency?: CurrencyCodeFiat;
}

interface FeeService {
    /**
     * Returns the tax and fee data
     *
     * @remarks
     * This method is part of tax and fee service
     *
     * @param param - tax and fee param {@link EstimateTaxAndRoyaltyFeeParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link EstimateTaxAndRoyaltyFeeData} tax and fee data
     *
     */
    estimateTaxAndRoyaltyFee: (param: EstimateTaxAndRoyaltyFeeParam, options?: QueryOptions) => Promise<Response<EstimateTaxAndRoyaltyFeeData>>;
    /**
     * Returns tax data
     *
     * @remarks
     * This method is part of tax and fee service
     *
     * @param param - tax param {@link GetTaxQuoteParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetTaxQuoteData} tax data
     *
     */
    getTaxQuote: (param: GetTaxQuoteParam, options?: QueryOptions) => Promise<Response<GetTaxQuoteData>>;
}

/**
 * Returns tax and fee service
 *
 * @remarks
 * This method is part of the tax and fee service
 *
 * @returns {@link FeeService} tax and fee service
 *
*/
declare const useFee: () => FeeService;

interface NFTPrice$2 {
    value: number;
    unit: string;
    type: string;
}
interface User {
    id: string;
    username: string;
    name: string;
    email: string;
    avatar: string;
}
interface MetaData$1 {
    name: string;
    description: string;
    image: string;
    animationURL?: string;
    openSeaImageURL?: string;
}
interface Artist {
    id: string;
    description: string;
    artistName: string;
    artistLocation: string;
    artistContactEmail: string;
    artistContactNumber: string;
    artistWebsite: string;
    slug?: string;
}
interface Registry {
    ID: string;
    NetworkID: string;
    Network: {
        name: string;
    };
    OrganizationID: string;
    CollectionName: string;
    ContractAddress: string;
    IsAllTokensApproved: boolean;
    MarketplaceID: string;
    TotalApproved: number;
    CollectionTotal: number;
    ArtistID: string;
    Artist: Artist;
    CategoryID: string;
    CreatedByUserID: string;
    CreatedAt: string;
    UpdatedAt: string;
}
declare enum TokenType$1 {
    erc721 = "ERC721",
    erc1155 = "ERC1155"
}
declare enum ListingStatus {
    ACTIVE = "Active",
    INACTIVE = "InActive"
}
declare enum TokenStatus {
    NEW = "NEW",
    ENQUIRY_PENDING = "ENQUIRY_PENDING",
    OPEN_FOR_SALE = "OPEN_FOR_SALE",
    SALE_PENDING = "SALE_PENDING",
    STALE_OWNERSHIP = "STALE_OWNERSHIP"
}
interface AllRegistryTokens {
    ID: string;
    TokenName: string;
    TokenID: number;
    MetaData: MetaData$1;
    TokenType: TokenType$1;
    ListingStatus: ListingStatus;
    OwnersList?: string[];
    Owners: string;
    RegistryId: string;
    Registry: Registry;
    Price: {
        buyNowPrice: NFTPrice$2[];
        lastPurchasedPrice: NFTPrice$2[];
        makeOfferHighestPrice: NFTPrice$2[];
        makeOfferLatestPrice: NFTPrice$2[];
    };
    Artist: Artist;
    CreatedBy: string;
    CreatedAt?: string;
    UpdatedAt?: string;
    Status?: TokenStatus;
    mediaSourceURL?: string;
    mediaSourceExtension?: string;
    TokenURI?: string;
    NFTTokenID?: string;
    MintedAt?: string;
    networkID?: string;
    editionNumber?: number;
    TokenOwnerAddress?: string;
    nftContractName?: string;
    networkName?: string;
    latestOffer?: {
        price: NFTPrice$2[];
    };
    listedOrderInfo?: {
        id: string;
        listedCurrency: {
            contractAddress: string;
        };
        price: NFTPrice$2[];
    };
    isBuyNowEnabled?: boolean;
    isMakeOfferEnabled?: boolean;
    isOfferExist?: boolean;
    offerOrder?: {
        id: string;
        nftTokenId: string;
        fixedPrice: number;
        offerExpiryDate: string;
        price: NFTPrice$2[];
    };
    offerOrderId?: string;
}
interface GetAllRegistryTokensData {
    getAllRegistryTokens?: {
        data: AllRegistryTokens[];
        totalCount: number;
        user: User | null;
        latestSoldPrice?: NFTPrice$2[];
        highestSoldPrice?: NFTPrice$2[];
        lowestSoldPrice?: NFTPrice$2[];
    };
}
interface GetAllRegistryTokensV2Data {
    getAllRegistryTokensV2?: {
        data: AllRegistryTokens[];
        totalCount: number;
        user: User | null;
        latestSoldPrice?: NFTPrice$2[];
        highestSoldPrice?: NFTPrice$2[];
        lowestSoldPrice?: NFTPrice$2[];
    };
}
interface RegistryCollections {
    ID: string;
    CollectionName: string;
    ContractAddress: string;
    collectionDescription?: string;
    collectionImage?: string;
    ContractType: string;
    CollectionTotal: number;
    Network: {
        id: string;
        name: string;
        chainID: number;
    };
}
interface GetRegistryCollectionsData {
    getRegistriesV1?: {
        totalCount: number;
        data: RegistryCollections[];
    };
}

interface NFTPrice$1 {
    value: number;
    unit: string;
    type: string;
}
interface OrderData {
    id: string;
    nftTokenId: string;
    tokenId: string;
    tokenContract: string;
    quantity: number;
    nftOwnerAddress: string;
    fixedPrice: number;
    price: NFTPrice$1[];
    nftToken: {
        id: string;
        name?: string;
        deployed?: boolean;
        tokenMetadata?: {
            name: string;
            description: string;
            image: string;
        };
        nftContractID: string;
    };
}
interface BubbleGumParams {
    buyer: string;
    seller: string;
    buyerTokenAccount: string;
    sellerTokenAccount: string;
    systemProgram: string;
    tokenProgram: string;
    bubblegumProgram: string;
    compressionProgram: string;
    treeAuthority: string;
    leafOwner: string;
    leafDelegate: string;
    newLeafDelegate: string;
    logWrapper: string;
    merkleTree: string;
    buyDiscriminator: number[];
    marketplaceAddress: string;
    mintAccount: string;
    buyerVinTokenAccount: string;
    sellerVinTokenAccount: string;
    commissionVinTokenAccount: string;
    platformVinTokenAccount: string;
    initializeAccount: string;
    metadataId: string;
    listing: string;
    bubblegumArg: {
        amount: number;
        dataHash: string;
        creatorHash: string;
        nonce: number;
        index: number;
        root?: string;
        proof?: string[];
    };
    offer: string;
    offerEscrow: string;
    delegateAuthority?: string;
    acceptOfferDiscriminator: number[];
}
interface InitiateBuyNFTData {
    initiateBuyNFT?: {
        proofOfApproval: string;
        order: OrderData;
        Network?: {
            id: string;
            name: string;
            chainID: number;
            wethAddress: string;
        };
        bubblegumParams?: BubbleGumParams;
        isNonEVM: boolean;
    };
}
interface UpdateTransactionHashData {
    updateTransactionHash?: {
        success: boolean;
        newNFTID: string;
        order?: {
            id: string;
            nftTokenId: string;
            fixedPrice: number;
            price: NFTPrice$1[];
        };
    };
}
interface GenerateSecondaryInvoiceData {
    generateSecondaryInvoice: string;
}
interface GeneratePrimaryInvoiceData {
    generatePrimaryInvoice: string;
}
declare enum ActivityNameEnum {
    Listed_Item = 0,
    Listed_Item_Removed = 1,
    Sold_Item = 2,
    Offered = 3,
    Offer_Cancelled = 4,
    Offer_Rejected = 5,
    Offer_Expired = 6,
    Bought_Item = 7
}
declare enum OrderStatusEnum {
    PENDING = 0,
    CANCELLED = 1,
    REJECTED = 2,
    FAILED = 3,
    COMPLETED = 4,
    EXPIRED = 5
}
interface WalletData {
    id: string;
    name: string;
    address: string;
}
interface UserOrderActivityData {
    getUserOrderActivity: {
        totalCount: number;
        data?: {
            ActivityName: ActivityNameEnum;
            TokenName: string;
            TokenID: number;
            NFTTokenID: string;
            ContractName: string;
            ContractAddress: string;
            Price?: NFTPrice$1[];
            NetworkID: string;
            TransactionHash: string;
            FromUserName: string;
            ToUserName: string;
            FromUserAvatar: string;
            ToUserAvatar: string;
            FromWallet?: WalletData;
            ToWallet?: WalletData;
            InvoiceURL: string;
            InvoiceID: string;
            Status: OrderStatusEnum;
            CreatedAt: string;
            cryptoTax?: {
                cryptoTaxPrice: number;
                cryptoTotalPrice: number;
                USDUnitprice: number;
                taxPercentage: number;
            };
            order?: {
                creatorFee: number;
                platformFee: number;
            };
            OrderID: string;
            nftImageUrl?: string;
        }[];
    };
}
interface CompleteOnchainBuyData {
    completeOnchainBuy: boolean;
}
interface SaveUserWalletSessionData {
    saveUserWalletSession: {
        user: {
            id: string;
        };
        wallet: {
            address: string;
        };
    };
}

interface AddNFTToFavoriteData {
    addNFTToFavourite?: boolean;
}
interface RemoveNFTFromFavoriteData {
    removeNFTFromFavourite?: boolean;
}
interface Tokens {
    contractAddress: string;
    id: string;
    network: string;
    networkID: string;
    metadata: MetaData$1;
    tokenType: string;
    nftTokenId: string;
    balance: string;
    title: string;
    description: string;
    tokenURI: string;
    timeLastUpdated: string;
    mintedAt: string;
    contractName: string;
    status: TokenStatus;
    listedAt: string;
    artistName: string;
    mediaSourceURL: string;
    mediaSourceExtension: string;
    price: {
        buyNowPrice: NFTPrice$2[];
        lastPurchasedPrice: NFTPrice$2[];
        makeOfferHighestPrice: NFTPrice$2[];
        makeOfferLatestPrice: NFTPrice$2[];
    };
    favouriteCount?: number;
    owner?: string;
    editionNumber: number;
    latestOffer: {
        price: NFTPrice$2[];
    };
    listedOrderInfo: {
        id: string;
        listedCurrency: {
            contractAddress: string;
        };
        price: NFTPrice$2[];
    };
    isBuyNowEnabled: boolean;
    isMakeOfferEnabled: boolean;
    isOfferExist: boolean;
}
interface GetNFTFavoriteListByUserData {
    getNFTFavouriteListByUser?: {
        data: Tokens[];
        totalCount: number;
    };
}

interface MetadataAttributes$1 {
    traitType: string;
    value: {
        intValue?: number;
        floatValue?: number;
        stringValue?: string;
        boolValue?: string;
        __typename?: string;
    };
    displayType: string;
    maxValue: number;
    prevalance?: number;
}
interface Metadata {
    name: string;
    description: string;
    image: string;
    attributes: MetadataAttributes$1[];
    externalURL: string;
    backgroundColor: string;
    animationURL: string;
    timestamp: number;
    language: string;
    openSeaImageURL?: string;
    tags: string[];
    yearCreated: string;
    createdBy: string;
}
interface GetNFTDetailsData {
    getNFTDetails?: {
        contractAddress: string;
        tokenId: number;
        network: string;
        owner: string;
        contractName: string;
        tokenType: string;
        mintedAt: string;
        status: TokenStatus;
        metadata: Metadata;
        artist: Artist;
        isMakeOfferEnabled: boolean;
        isBuyNowEnabled: boolean;
        isOfferExist: boolean;
        mediaSourceExtension: string;
        mediaSourceType: string;
        mediaSourceURL: string;
        listedOrderInfo: {
            id: string;
            listedCurrency: {
                contractAddress: string;
            };
            price: NFTPrice$2[];
        };
        latestOffer: {
            price: NFTPrice$2[];
        };
        balance: number;
        price: {
            buyNowPrice: NFTPrice$2[];
            lastPurchasedPrice: NFTPrice$2[];
            makeOfferHighestPrice: NFTPrice$2[];
            makeOfferLatestPrice: NFTPrice$2[];
        };
        isFavorite: boolean;
        nftTokenId: string;
        tokenURI: string;
        networkID: string;
        tokenOwnerAvatar: string;
        tokenOwnerAddress: string;
        tokenOwnerUsername: string;
        editions: number;
        editionNumber: number;
    };
}
interface ERC1155Metadata {
    tokenId: number;
    value: number;
}
interface HistoryData {
    blockNum: number;
    hash: string;
    from: string;
    to: string;
    value: number;
    erc1155Metadata: [ERC1155Metadata];
    tokenId: number;
    category: string;
    asset: string;
    price: {
        value: number;
        unit: string;
        type: string;
    }[];
    blockTimestamp: string;
    eventType: string;
    fromUserAvatar: string;
    fromUserName: string;
    toUserAvatar: string;
    toUserName: string;
}
interface GetNFTHistoryData {
    getNFTHistoryV2?: {
        totalCount: number;
        data: HistoryData[] | null;
    };
}
interface TraitsData$1 {
    traitType: number;
    value: {
        AttributeValueString: string;
        AttributeValueInt: number;
        AttributeValueFloat: number;
        AttributeValueBool: boolean;
    };
    displayType: string;
    maxValue: number;
    prevalance: number;
}
interface GetNFTAttributesRarityData {
    getNFTAttributesRarity?: TraitsData$1[];
}

interface TransferNFTData {
    transferToken?: string;
}

interface GetAllInvoicesData {
    getAllInvoices?: {
        count: number;
        data: {
            id: string;
            createdAt: string;
            isSecondary: boolean;
            userID: string;
            status: string;
            totalPrice: number;
            PriceCrypto: number;
            usdItemPrice: number;
            quantity: number;
            transactionHash: string;
            invoiceID: string;
            invoiceNumber: number;
            itemID: string;
            tokenID: string;
            contractAddress: string;
            onChainTokenID: string;
            networkID: string;
            eventType: string;
            fromWalletAddress: string;
            toWalletAddress: string;
            image: string;
            itemName: string;
            tokenName: string;
            transactionStatus: string;
        }[];
    };
}
type TokenMetaData = {
    name: string;
    description: string;
    image: string;
};
type NftDetails = {
    contractAddress: string;
    networkId: string;
    nftTokenID: string;
    networkChainID: number;
    isRevealed: boolean;
    tokenMetadata: TokenMetaData;
};
type GetMyInvoiceDataItems = {
    collectionItemTitle: string;
    collectionItemID: string;
    collectionItemImage: string;
    invoiceItemID: string;
    destinationAddress: string;
    units: number;
    totalPrice: number;
    transactionHash: string;
    unitPrice: number;
    cryptoUnitPrice: number;
    transactionStatus: string;
    nftImageUrl: string;
    nftDetails?: NftDetails[];
};
type GetMyInvoiceData = {
    invoiceID: string;
    invoiceCreatedAt: string;
    invoiceNumber: number;
    status: string;
    items: GetMyInvoiceDataItems[];
};
interface GetMyInvoicesData {
    getMyInvoicesData?: {
        TotalCount: number;
        data: GetMyInvoiceData[];
    };
}

interface FileSignedUrlData {
    mediaURL: string;
    type: string;
    contentType: string;
    expiryDuration: string;
}

interface TraitValues {
    traitValue: string;
    count: number;
}
interface GetCollectionTraitResponse {
    traitType: string;
    dataType: string;
    traitValues: TraitValues[];
}
interface TraitsData {
    GetCollectionTraitforSMP?: GetCollectionTraitResponse[];
}

declare enum RegistryTokenFilterInput {
    RECENTLY_LISTED = "recently_listed",
    RECENTLY_MINTED = "recently_minted",
    INITIALLY_MINTED = "initially_minted",
    PRICE_LOW_TO_HIGH = "price_low_to_high",
    PRICE_HIGH_TO_LOW = "price_high_to_low"
}
declare enum RegistryTokenColumnType {
    TOKEN_NAME = "tokenName",
    TOKEN_TYPE = "tokenType",
    TOKEN_ID = "tokenID",
    PRIORITY = "priority"
}
declare enum OrderType {
    ASC = "ASC",
    DESC = "DESC"
}
interface RegistryTokenSortInput {
    column: RegistryTokenColumnType;
    type: OrderType;
}
interface GetAllRegistryTokensParam {
    orgID: string;
    marketplaceID?: string;
    owner?: string;
    offset?: number;
    limit?: number;
    searchKey?: string;
    filters?: RegistryTokenFilterInput;
    sort?: RegistryTokenSortInput;
    categoryID?: string;
    buyerAddress?: string;
    artistID?: string;
    registryID?: string;
    categorySlug?: string;
    artistSlug?: string;
}
declare enum RegistryTokenStatus {
    NEW = "NEW",
    ENQUIRY_PENDING = "ENQUIRY_PENDING",
    OPEN_FOR_SALE = "OPEN_FOR_SALE",
    SALE_PENDING = "SALE_PENDING",
    STALE_OWNERSHIP = "STALE_OWNERSHIP"
}
interface RegistryFilterMetadata {
    traitType: string;
    traitValue: string[];
}
declare enum RegistryCurrency {
    USD = "USD",
    EUR = "EUR"
}
interface SimilarNFTFilterProp {
    nftTokenId: string;
    traitType: string[];
}
interface GetAllRegistryTokensV2Params {
    orgID: string;
    marketplaceID?: string;
    owner?: string;
    offset?: number;
    limit?: number;
    searchKey?: string;
    categoryID?: string;
    artistID?: string;
    artistSlug?: string;
    categorySlug?: string;
    contractAddress?: string;
    status?: RegistryTokenStatus;
    registryID?: string;
    filters?: RegistryTokenFilterInput;
    filterByMetadata?: RegistryFilterMetadata[];
    sort?: RegistryTokenSortInput;
    buyerAddress?: string;
    chainID?: number;
    offerPriceSorting?: boolean;
    currency?: RegistryCurrency;
    similarNFTFilter?: SimilarNFTFilterProp;
}
declare enum RegistryCollectionSortColumns {
    COLLECTION_NAME = "collectionName",
    CREATED_AT = "createdAt",
    COLLECTION_TOTAL = "collectionTotal",
    TOTAL_APPROVED = "totalApproved"
}
interface RegistryCollectionSortInput {
    column: RegistryCollectionSortColumns;
    type: OrderType;
}
interface GetRegistriesV1Params {
    orgID: string;
    marketplaceID: string;
    registryId?: string;
    sort?: RegistryCollectionSortInput;
    offset?: number;
    limit?: number;
}

interface CryptoTax$1 {
    cryptoTaxPrice: number;
    cryptoTotalPrice: number;
    USDUnitprice: number;
    taxPercentage: number;
}
interface TaxAddressInput$1 {
    street1: string;
    city: string;
    state: string;
    postalCode: string;
    country: string;
}
interface InitiateBuyNFTParam {
    nftTokenId: string;
    buyerAddress: string;
    orgId: string;
    country?: string;
    postalCode?: string;
    currencyId?: string;
    cryptoTax?: CryptoTax$1;
    taxAddress?: TaxAddressInput$1;
}
interface UpdateTransactionHashParam {
    nftTokenId: string;
    orgId: string;
    transactionHash: string;
    buyerAddress: string;
    orderId?: string;
}
interface GenerateSecondaryInvoiceParam {
    invoiceID: string;
    orderID: string;
    activityName: string;
    invoiceResType: string;
}
interface GeneratePrimaryInvoiceParam {
    invoiceID: string;
    invoiceResType: string;
}
interface GetUserOrderActivityParam {
    orgId: string;
    filter: string;
    limit: number;
    offset: number;
}
interface CompleteOnchainBuyParam {
    networkChainId: number;
    txHash: string;
}
interface SaveUserWalletSessionParam {
    walletAddress: string;
    networkChainId: number;
    userSessionInput: {
        organizationID: string;
        eventType?: string;
        sessionType?: string;
        customerIp?: string;
        ipType?: string;
        countryName?: string;
        region?: string;
        city?: string;
        zip?: string;
        latitude?: number;
        longitude?: number;
        deviceType?: string;
        browserType?: string;
    };
}

interface FavoriteParam {
    orgID: string;
    tokenId: string;
}
declare enum SavedNFTFilterInput {
    RECENTLY_LISTED = "recently_listed",
    RECENTLY_MINTED = "recently_minted",
    INITIALLY_MINTED = "initially_minted",
    PRICE_LOW_TO_HIGH = "price_low_to_high",
    PRICE_HIGH_TO_LOW = "price_high_to_low",
    MOST_SAVED = "most_saved",
    PURCHASED_FROM_ORG = "purchased_from_org"
}
interface FavoriteListByUserParam {
    orgId: string;
    offset?: number;
    limit?: number;
    searchKey?: string;
    filter?: SavedNFTFilterInput;
    buyerAddress?: string;
}

interface GetNFTDetailsParam {
    orgId: string;
    networkId?: string;
    contractAddress?: string;
    onChainTokenID?: string;
    nftTokenId?: string;
    editionNumber?: number;
    ownerAddress?: string;
    buyerAddress?: string;
    currency?: CurrencyCodeFiat;
}
declare enum NFTTxEventType {
    TRANSFER = "Transfer",
    OFFER = "Offer",
    MINTED = "Minted",
    LIST = "List",
    LIST_REMOVED = "List_Removed",
    SALE = "Sale",
    OFFER_SOLD = "Offer_Sold",
    EXPIRED = "Expired",
    OFFER_REJECTED = "Offer_Rejected",
    OFFER_CANCELLED = "Offer_Cancelled"
}
interface GetNFTHistoryParam {
    networkId: string;
    contractAddress: string;
    tokenId: number;
    orgId: string;
    nftTokenId?: string;
    filterBy?: NFTTxEventType;
    ownerAddress?: string;
    offset?: number;
    limit?: number;
    currency?: CurrencyCodeFiat;
}
interface GetNFTAttributesRarityParam {
    contractAddress: string;
    tokenID: number;
    networkID: string;
    refreshCatch?: boolean;
}

interface TransferNFTParam {
    walletId: string;
    orgId: string;
    contractAddress: string;
    tokenType: string;
    tokenOnChainId: number;
    amount?: number;
    transferTo: string;
    isClaimedToken?: boolean;
}

interface GetAllInvoicesParam {
    orgID: string;
    filter: string;
    limit: number;
    offset: number;
    status?: string[];
    fiatCurrency?: CurrencyCodeFiat;
}
interface GetMyInvoiceFilterParam {
    dropID?: string;
    listingID?: string;
}
interface GetMyInvoicesParam {
    returnAllStatuses?: boolean;
    filter?: GetMyInvoiceFilterParam;
    limit: number;
    offset: number;
}

interface FileSignedWithURL {
    url: string;
    contractAddress: string;
    tokenID: string;
}
interface GatingType {
    groupID: string;
    ruleID?: string;
}
interface FileSignedWithGatingInput {
    url: string;
    contractAddress?: string;
    tokenID?: string;
    gating: GatingType;
}
interface FileSignedUrlParam {
    urlInput?: FileSignedWithURL;
    input?: FileSignedWithGatingInput;
}

interface GetCollectionTraitParam {
    orgID: string;
    marketplaceID?: string;
    registryID?: string;
}

interface NFTService {
    /**
     * Returns favorite NFT list by user
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - favorite list by user param {@link FavoriteListByUserParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetNFTFavoriteListByUserData} favorite list
     *
     */
    getNFTFavoriteListByUser: (param: FavoriteListByUserParam, options?: QueryOptions) => Promise<Response<GetNFTFavoriteListByUserData>>;
    /**
     * Returns the success message
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - add favorite param {@link FavoriteParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link AddNFTToFavoriteData} success message
     *
     */
    addNFTToFavorite: (param: FavoriteParam, options?: QueryOptions) => Promise<Response<AddNFTToFavoriteData>>;
    /**
     * Returns the success message
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - add favorite param {@link FavoriteParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link RemoveNFTFromFavoriteData} success message
     *
     */
    removeNFTFromFavorite: (param: FavoriteParam, options?: QueryOptions) => Promise<Response<RemoveNFTFromFavoriteData>>;
    /**
     * Returns the transaction details
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - add initiate buy now param {@link InitiateBuyNFTParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link InitiateBuyNFTData} transaction details
     *
     */
    initiateBuyNFT: (param: InitiateBuyNFTParam, options?: QueryOptions) => Promise<Response<InitiateBuyNFTData>>;
    /**
     * Returns the transaction details
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - update transaction hash param {@link UpdateTransactionHashParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link UpdateTransactionHashData} transaction details
     *
     */
    updateTransactionHash: (param: UpdateTransactionHashParam, options?: QueryOptions) => Promise<Response<UpdateTransactionHashData>>;
    /**
     * Returns pdf url to download the invoice
     *
     * @remarks
     * This method is part of NFT module, fetch invoice details
     *
     * @param param - param {@link GenerateSecondaryInvoiceParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GenerateSecondaryInvoiceData} invoice Data
     *
     */
    generateSecondaryInvoice: (param: GenerateSecondaryInvoiceParam, options?: QueryOptions) => Promise<Response<GenerateSecondaryInvoiceData>>;
    /**
   * Returns pdf url to download the primary marketplace invoice
   *
   * @remarks
   * This method is part of NFT module, fetch invoice details
   *
   * @param param - param {@link GeneratePrimaryInvoiceParam}
   * @param options - graphql fetch query options {@link QueryOptions}
   * @returns {@link GeneratePrimaryInvoiceData} invoice Data
   *
   */
    generatePrimaryInvoice: (param: GeneratePrimaryInvoiceParam, options?: QueryOptions) => Promise<Response<GeneratePrimaryInvoiceData>>;
    /**
     * Returns On user order activity Details
     *
     * @remarks
     * This method is part of NFT module, fetch user order activity
     *
     * @param param - param {@link GetUserOrderActivityParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link UserOrderActivityData} user order activity data
     *
     */
    userOrderActivity: (param: GetUserOrderActivityParam, options?: QueryOptions) => Promise<Response<UserOrderActivityData>>;
    /**
     * Returns Collections list
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - Collection list param {@link GetRegistriesV1Params}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetRegistryCollectionsData} NFT list
     *
     */
    getRegistryCollections: (param: GetRegistriesV1Params, options?: QueryOptions) => Promise<Response<GetRegistryCollectionsData>>;
    /**
     * Returns NFT list
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - NFT list param {@link GetAllRegistryTokensParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetAllRegistryTokensData} NFT list
     *
     */
    getAllRegistryTokens: (param: GetAllRegistryTokensParam, options?: QueryOptions) => Promise<Response<GetAllRegistryTokensData>>;
    /**
     * Returns NFT list
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - NFT list param {@link GetAllRegistryTokensV2Params}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetAllRegistryTokensV2Data} NFT list
     *
     */
    getAllRegistryTokensV2: (param: GetAllRegistryTokensV2Params, options?: QueryOptions) => Promise<Response<GetAllRegistryTokensV2Data>>;
    /**
     * Returns Traits for the marketplace or organization
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - collection traits query param {@link GetCollectionTraitParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link TraitsData} Traits data
     *
     */
    getCollectionTraits: (param: GetCollectionTraitParam, options?: QueryOptions) => Promise<Response<TraitsData>>;
    /**
     * Returns NFT details
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - NFT details param {@link GetNFTDetailsParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetNFTDetailsData} NFT details
     *
     */
    getNFTDetails: (param: GetNFTDetailsParam, options?: QueryOptions) => Promise<Response<GetNFTDetailsData>>;
    /**
     * Returns NFT history list
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - NFT history param {@link GetNFTHistoryParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetNFTHistoryData} NFT history list
     *
     */
    getNFTHistory: (param: GetNFTHistoryParam, options?: QueryOptions) => Promise<Response<GetNFTHistoryData>>;
    /**
     * Returns NFT traits list
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - NFT traits param {@link GetNFTAttributesRarityParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetNFTAttributesRarityData} NFT traits list
     *
     */
    getNFTAttributesRarity: (param: GetNFTAttributesRarityParam, options?: QueryOptions) => Promise<Response<GetNFTAttributesRarityData>>;
    /**
     * Returns the success message
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - add transferNFT param {@link TransferNFTParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link TransferNFTData} success message
     *
     */
    transferNFT: (param: TransferNFTParam, options?: QueryOptions) => Promise<Response<TransferNFTData>>;
    /**
     * Returns On All Invoice Details
     *
     * @remarks
     * This method is part of NFT Service
     *
     * @param param - param {@link GetAllInvoicesParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetAllInvoicesData} all invoices data
     *
     */
    getAllInvoices: (param: GetAllInvoicesParam, options?: QueryOptions) => Promise<Response<GetAllInvoicesData>>;
    /**
 * Returns On My Invoice Details
 *
 * @remarks
 * This method is part of NFT Service
 *
 * @param param - param {@link GetMyInvoicesParam}
 * @param options - graphql fetch query options {@link QueryOptions}
 * @returns {@link GetMyInvoicesData} all invoices data
 *
 */
    getMyInvoices: (param: GetMyInvoicesParam, options?: QueryOptions) => Promise<Response<GetMyInvoicesData>>;
    /**
     * Returns the url data
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - get FileSignedUrl param {@link FileSignedUrlParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link FileSignedUrlData} FileSigned Url
     *
     */
    getFileSignedUrl: (param: FileSignedUrlParam, options?: QueryOptions) => Promise<Response<FileSignedUrlData>>;
    /**
     * Returns the boolean
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - completed transaction hash param {@link CompleteOnchainBuyParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CompleteOnchainBuyData} transaction status
     *
     */
    completeOnchainBuy: (param: CompleteOnchainBuyParam, options?: QueryOptions) => Promise<Response<CompleteOnchainBuyData>>;
    /**
     * Returns the user details
     *
     * @remarks
     * This method is part of NFT service
     *
     * @param param - user details param {@link SaveUserWalletSessionParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link SaveUserWalletSessionData} user details
     *
     */
    saveUserWalletSession: (param: SaveUserWalletSessionParam, options?: QueryOptions) => Promise<Response<SaveUserWalletSessionData>>;
}

/**
 * Returns NFT service
 *
 * @remarks
 * This method is part of the NFT service
 *
 * @returns {@link NFTService} NFT service
 *
 */
declare const useNFT: () => NFTService;

interface NFTPrice {
    value: number;
    unit: string;
    type: string;
}
interface GetOffer {
    id: string;
    offerExpiryDate: string;
    nftOwnerAddress: string;
    tokenType: string;
    tokenId: string;
    tokenContract: string;
    orderStatus: string;
    buyerAddress: string;
    buyerTax: number;
    fixedPrice: number;
    updatedAt: string;
    createdAt: string;
    price: NFTPrice[];
    createdBy: {
        id: string;
        username: string;
    };
    createdByUserOrganization: {
        username: string;
    };
}
interface GetOffersData {
    getOffers: GetOffer[];
}
interface CancelOfferData {
    cancelOffer: string;
}
interface RejectOfferData {
    rejectOffer: string;
}
interface CreateOfferData {
    createOffer: {
        messageToSign: string;
        order: {
            id: string;
            nftTokenId: string;
            tokenId: string;
            tokenContract: string;
            quantity: number;
            nftOwnerAddress: string;
            fixedPrice: number;
            nftToken: {
                id: string;
                name?: string;
                deployed: boolean;
                tokenMetadata?: {
                    name: string;
                    description: string;
                    image: string;
                };
                nftContractID: string;
            };
        };
        isSigningRequired: boolean;
        isNonEVM: boolean;
        bubblegumListParams?: BubbleGumListParams;
        bubblegumMakeOfferParams?: BubblegumMakeOfferParams;
    };
}
interface SubmitProofOfOfferData {
    submitProofOfOffer: string;
}
interface AcceptOfferData {
    acceptOffer: {
        success: boolean;
        newNFTID: string;
    };
}
declare enum TokenType {
    ERC721 = 0,
    ERC1155 = 1
}
declare enum NFTOrderType {
    LISTING = 0,
    OFFER = 1
}
declare enum OrderStatus {
    PENDING = 0,
    CANCELLED = 1,
    REJECTED = 2,
    FAILED = 3,
    COMPLETED = 4,
    EXPIRED = 5,
    REMOVED = 6,
    PROCESSING = 7
}
interface GetSignatureForOfferApprovalData {
    getSignatureForOfferApproval: {
        proofOfApproval: string;
        order: {
            id: string;
            nftTokenId: string;
            tokenId: string;
            tokenType: TokenType;
            quantity: number;
            nftOwnerAddress: string;
            fixedPrice: number;
            price: NFTPrice[];
            buyerAddress: string;
            buyerTax: number;
            paymentToken: string;
            orderType: NFTOrderType;
            orderStatus: OrderStatus;
        };
        Network?: {
            id: string;
            name: string;
            chainID: number;
            rpcURL: string;
            wethAddress: string;
            defaultCurrency: string;
            isTestnet: boolean;
            paymentCurrency: string;
        };
        bubblegumParams?: BubbleGumParams;
    };
}
interface InitiateRejectOfferData {
    initiateRejectOffer: {
        seller: string;
        sellerTokenAccount: string;
        buyer: string;
        offer: string;
        offerEscrow: string;
        systemProgram: string;
        descriminator: number[];
        mintAccount?: string;
    };
}
interface InitiateCancelOfferData {
    initiateCancelOffer: {
        seller: string;
        sellerTokenAccount: string;
        buyer: string;
        offer: string;
        offerEscrow: string;
        systemProgram: string;
        descriminator: number[];
        mintAccount?: string;
    };
}

interface GetOffersParam {
    nftTokenId: string;
    orgId: string;
    buyerAddress?: string;
    walletAddress?: string;
    gatedOffers?: boolean;
    currency?: CurrencyCodeFiat;
}
interface CancelOrRejectOfferParam {
    orderId: string;
    orgId: string;
    walletAddress?: string;
    currency?: CurrencyCodeFiat;
    signature?: string;
}
interface TaxAddressInput {
    street1: string;
    city: string;
    state: string;
    postalCode: string;
    country: string;
}
interface CryptoTax {
    cryptoTaxPrice: number;
    cryptoTotalPrice: number;
    USDUnitprice: number;
    taxPercentage: number;
}
interface CreateOfferParam {
    nftTokenId: string;
    orgId: string;
    buyerAddress: string;
    offerPrice: number;
    expiryDate: string;
    paymentToken: string;
    currencyId?: string;
    cryptoTax?: CryptoTax;
    taxAddress?: TaxAddressInput;
    currency?: CurrencyCodeFiat;
}
interface SubmitProofOfOfferParam {
    orderId: string;
    orgId: string;
    signature: string;
    buyerAddress?: string;
    currency?: CurrencyCodeFiat;
    offerReceipt?: string;
}
interface AcceptOfferParam {
    orderId: string;
    orgId: string;
    transactionHash: string;
    paymentSettlementAddress?: string;
    currency?: CurrencyCodeFiat;
}
interface GetSignatureForOfferApprovalParam {
    orderId: string;
    orgId: string;
    creatorFee?: number;
}
interface InitiateRejectOfferParam {
    orderId: string;
    orgId: string;
    walletAddress: string;
}
interface InitiateCancelOfferParam {
    orderId: string;
    orgId: string;
}

interface OfferService {
    /**
     * Returns offers list
     *
     * @remarks
     * This method is part of offer service
     *
     * @param param - get offers param {@link GetOffersParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetOffersData} Offers data
     *
     */
    getOffers: (param: GetOffersParam, options?: QueryOptions) => Promise<Response<GetOffersData>>;
    /**
     * Returns the success response
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - cancel offer param {@link CancelOrRejectOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CancelOfferData} success response
     *
     */
    cancelOffer: (param: CancelOrRejectOfferParam, options?: QueryOptions) => Promise<Response<CancelOfferData>>;
    /**
       * Returns the success response
       *
       * @remarks
       * This method is part of Offer service
       *
       * @param param - cancel offer param {@link InitiateCancelOfferParam}
       * @param options - graphql fetch query options {@link QueryOptions}
       * @returns {@link InitiateCancelOfferData} success response
       *
       */
    initiateCancelOffer: (param: InitiateCancelOfferParam, options?: QueryOptions) => Promise<Response<InitiateCancelOfferData>>;
    /**
     * Returns the success response
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - reject offer param {@link CancelOrRejectOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link RejectOfferData} success response
     *
     */
    rejectOffer: (param: CancelOrRejectOfferParam, options?: QueryOptions) => Promise<Response<RejectOfferData>>;
    /**
     * Returns the data for reject offer params
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - initiate reject offer param {@link InitiateRejectOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link InitiateRejectOfferData} success response
     *
     */
    initiateRejectOffer: (param: InitiateRejectOfferParam, options?: QueryOptions) => Promise<Response<InitiateRejectOfferData>>;
    /**
     * Returns the signature message and order data
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - create offer param {@link CreateOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link CreateOfferData} signature message and order data
     *
     */
    createOffer: (param: CreateOfferParam, options?: QueryOptions) => Promise<Response<CreateOfferData>>;
    /**
     * Returns the success response
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - submit proof of offer param {@link SubmitProofOfOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link SubmitProofOfOfferData} success response
     *
     */
    submitProofOfOffer: (param: SubmitProofOfOfferParam, options?: QueryOptions) => Promise<Response<SubmitProofOfOfferData>>;
    /**
     * Returns the order data
     *
     * @remarks
     * This method is part of Offer service
     *
     * @param param - accept offer param {@link AcceptOfferParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link AcceptOfferData} order data
     *
     */
    acceptOffer: (param: AcceptOfferParam, options?: QueryOptions) => Promise<Response<AcceptOfferData>>;
    /**
     * Returns approval data and order data
     *
     * @remarks
     * This method is part of offer service
     *
     * @param param - signature for offer approval param {@link GetSignatureForOfferApprovalParam}
     * @param options - graphql fetch query options {@link QueryOptions}
     * @returns {@link GetSignatureForOfferApprovalData} approval data and order data
     *
     */
    getSignatureForOfferApproval: (param: GetSignatureForOfferApprovalParam, options?: QueryOptions) => Promise<Response<GetSignatureForOfferApprovalData>>;
}

/**
 * Returns Offer service
 *
 * @remarks
 * This method is part of the Offer service
 *
 * @returns {@link OfferService} Offer service
 *
*/
declare const useOffer: () => OfferService;

declare enum RuleType {
    ContractAddress = "ContractAddress",
    ContractAddressWithTokenID = "ContractAddressWithTokenID",
    MetaData = "MetaData",
    Onchain = "Onchain"
}
declare enum Onchain {
    ONCHAIN = "ONCHAIN"
}
interface ContractAddressGating {
    contractAddress: string;
}
interface ContractAddressWithTokenIDGating {
    contractAddress: string;
    tokenID: number;
}
interface MetaDataGating {
    key: string;
    value: string;
}
interface MetaDataGatingInput {
    metaData: MetaDataGating[];
}
interface OnchainGating {
    onchain: Onchain;
}
interface GatingRule {
    ruleType: RuleType;
    contractAddress?: ContractAddressGating;
    contractAddressWithTokenId?: ContractAddressWithTokenIDGating;
    metaData?: MetaDataGatingInput;
    onchain?: OnchainGating;
}
interface GatingInput {
    orgID: string;
    networkId: string;
    groupId?: string;
    groupName?: string;
    rule: GatingRule;
}
interface CreateTokenGatingParam {
    input: GatingInput;
}
interface CheckTokenGatingParams {
    groupID: string;
    ruleID?: string;
    buyerAddress?: string;
    contractAddress?: string;
    tokenId?: string;
}
interface CheckTokenGatingV2Params {
    groupID: string;
    ruleID?: string;
    buyerAddress: string;
}

interface GatingRules {
    id: string;
    gatingGroupId: string;
    ruleType: RuleType;
    rules: {
        contractAddress?: string;
        tokenID?: number;
        metaData?: {
            key: string;
            value: string;
        }[];
        onchain?: Onchain;
    };
}
interface CreateTokenGatingData {
    createTokenGatingRule: {
        id: string;
        groupName: string;
        networkID: string;
        organizationID: string;
        rules: GatingRules[];
    };
}
interface MetadataAttributes {
    traitType: string;
    displayType: string;
    maxValue: number;
    value: {
        stringValue?: string;
        intValue?: number;
        floatValue?: number;
        boolValue?: boolean;
    };
}
interface MetaData {
    name: string;
    description: string;
    image: string;
    attributes: MetadataAttributes[];
    openSeaImageURL: string;
    animationURL?: string;
}
interface WalletToken {
    contractAddress: string;
    id: number;
    tokenType: string;
    title: string;
    description: string;
    tokenURI: string;
    contractName: string;
    metadata: MetaData;
    gatingRuleId: string;
}
interface CheckTokenGatingData {
    checkTokenGating: {
        isGated: boolean;
        walletAddress: string;
        message: string;
        eligibleTokens: number;
        gatedTokens: WalletToken[];
    };
}
interface CheckTokenGatingV2Data {
    checkTokenGatingV2: {
        isGated: boolean;
        walletAddress: string;
        message: string;
        eligibleTokens: number;
        gatedTokens: WalletToken[];
    };
}

interface TokenGatingService {
    /**
     * Returns Created Group id with rule data
     *
     * @remarks
     * This method is part of token gating module, to create Token Gating
     *
     * @param param - param {@link CreateTokenGatingParam}
     * @param options - graphql mutation options {@link MutationOptions}
     * @returns {@link CreateTokenGatingData} return created token gating group with rule detail
     *
     */
    createTokenGating: (param: CreateTokenGatingParam, options?: MutationOptions) => Promise<Response<CreateTokenGatingData>>;
    /**
     * To check whether the Token is gated or not
     *
     * @remarks
     * This method is part of token gating module, to check Token Gating
     *
     * @param param - param {@link CheckTokenGatingParams}
     * @param options - graphql query options {@link QueryOptions}
     * @returns {@link CheckTokenGatingData} return  gated token data
     *
     */
    checkTokenGating: (param: CheckTokenGatingParams, options?: QueryOptions) => Promise<Response<CheckTokenGatingData>>;
    /**
     * To check whether the Token is gated or not
     *
     * @remarks
     * This method is part of token gating module, to check Token Gating
     *
     * @param param - param {@link CheckTokenGatingV2Params}
     * @param options - graphql query options {@link QueryOptions}
     * @returns {@link CheckTokenGatingV2Data} return  gated token data
     *
     */
    checkTokenGatingV2: (param: CheckTokenGatingV2Params, options?: QueryOptions) => Promise<Response<CheckTokenGatingV2Data>>;
}

declare const useTokenGating: () => TokenGatingService;

interface TokenDetailsData {
    contractAddress: string;
    tokenId: string;
    tokenType: string;
    network?: {
        id: string;
        name: string;
        chainID: string;
    };
    metadata?: {
        name: string;
        image: string;
        video: string;
        description: string;
        animationURL: string;
        openSeaImageType: string;
        media?: {
            uri: string;
            dimensions: string;
            mimeType: string;
            size: string;
        };
    };
}
interface DetailsData {
    id: string;
    unitPrice: number;
    startDate: string;
    endDate: string;
    sortNumber: number;
    marketplaceCollectionItemId: string;
    status: string;
    marketplaceAuctionOnChainSettings: {
        id: string;
        networkID: string;
    };
    perWalletLimit: number;
    totalUnits: number;
    totalAvailableUnits: number;
    claimingType: string;
    marketplaceCollectionItem: {
        id: string;
    };
}
interface CollectionBySlugItems {
    id: string;
    slug: string;
    collectionSlug: string;
    name: string;
    saleType: string;
    collectionId: string;
    asset?: {
        currentVersion?: {
            id: string;
            cdnUrl: string;
            name: string;
        };
    };
    isReserved: boolean;
    NFTDetails?: TokenDetailsData[];
    details?: DetailsData;
    deliveryMethod?: string;
}
interface CollectionBySlugData {
    collectionBySlug: {
        id: string;
        items: CollectionBySlugItems[];
    };
}

interface CollectionBySlugParam {
    slug: string;
    marketplaceID: string;
}

interface CollectionService {
    /**
    * Returns the all listings from collection
    *
    * @remarks
    * This method is part of collection service
    *
    * @param param - param {@link CollectionBySlugParam}
    * @param options - graphql fetch query options {@link QueryOptions}
    * @returns {@link CollectionBySlugData} collections data
    *
    */
    collectionBySlug: (param: CollectionBySlugParam, options?: QueryOptions) => Promise<Response<CollectionBySlugData>>;
}

/**
 * Returns the collection service
 *
 * @remarks
 * This method is part of the collection service
 *
 * @returns {@link CollectionService} collection service
 *
*/
declare const useCollection: () => CollectionService;

interface AuthProp {
    sessionStatus: SessionStatus;
}
declare const useAuth: () => AuthProp;

export { AcceptOfferData, AcceptOfferParam, AddNFTToFavoriteData, AuctionByClaimCodeData, AuctionData, AuctionDetailsByClaimCodeParam, AuctionDetailsParam, AuctionService, BidsItemData, BubbleGumListParams, BubbleGumParams, BubblegumMakeOfferParams, CanRedeemClaimableData, CanRedeemClaimableParam, CanRedeemClaimableV2Data, CancelOfferData, CancelOrRejectOfferParam, CheckTokenGatingData, CheckTokenGatingParams, CheckTokenGatingV2Data, CheckTokenGatingV2Params, ClaimService, CollectionBySlugData, CollectionBySlugParam, CollectionItemByClaimCode, CollectionService, CompleteOnchainBuyData, CompleteOnchainBuyParam, CompleteOnchainClaimData, CompleteOnchainClaimParam, ConfirmOnChainBidParam, ConnectExternalWalletData, ConnectExternalWalletParam, ConnectWalletService, ConversionService, CoreServiceProvider, CoreServiceProviderProps, CreateApplicantData, CreateApplicantParam, CreateCheckData, CreateCheckParam, CreateMarketplaceAuctionBidParam, CreateMarketplaceAuctionBidResponse, CreateOfferData, CreateOfferParam, CreateSignatureToListNFTForSaleData, CreateSignatureToListNFTForSaleParam, CreateTokenGatingData, CreateTokenGatingParam, CryptoCurrencyCode, CurrencyCode, CurrencyCodeFiat, EditTokenListingData, EditTokenListingParam, EstimateTaxAndRoyaltyFeeData, EstimateTaxAndRoyaltyFeeParam, FavoriteListByUserParam, FavoriteParam, FeeService, FileSignedUrlData, FileSignedUrlParam, GeneratePrimaryInvoiceData, GeneratePrimaryInvoiceParam, GetActiveWalletsContentData, GetActiveWalletsContentParam, GetAllInvoicesData, GetAllInvoicesParam, GetAllRegistryTokensData, GetAllRegistryTokensParam, GetAllRegistryTokensV2Data, GetAllRegistryTokensV2Params, GetApplicantData, GetApplicantParam, GetClaimInvoiceDetailData, GetClaimInvoiceDetailParam, GetCollectionTraitParam, GetCollectionTraitResponse, GetContractDetailsData, GetContractDetailsParam, GetConversionRateData, GetConversionRateParam, GetMyInvoicesData, GetMyInvoicesParam, GetNFTAttributesRarityData, GetNFTAttributesRarityParam, GetNFTDetailsData, GetNFTDetailsParam, GetNFTFavoriteListByUserData, GetNFTHistoryData, GetNFTHistoryParam, GetOffersData, GetOffersParam, GetSDKTokenData, GetSDKTokenParam, GetSignatureData, GetSignatureForOfferApprovalData, GetSignatureForOfferApprovalParam, GetSignatureParam, GetSupportedCurrenciesData, GetSupportedCurrenciesParam, GetSupportedNetworksData, GetSupportedNetworksParam, GetTaxQuoteData, GetTaxQuoteParam, GetUSDConversionParam, GetUserData, GetUserParam, InitiateBuyNFTData, InitiateBuyNFTParam, InitiateCancelOfferData, InitiateCancelOfferParam, InitiateRejectOfferData, InitiateRejectOfferParam, InitiateRemoveListingData, InitiateRemoveListingParam, InitiateRemoveListingResponseData, InvoiceFilterInputData, KYCService, ListItemService, LoginWithSignatureData, LoginWithSignatureParam, MarketplaceAuctionLot, MarketplaceCollectionItemStatus, MarketplaceUser, MutationOptions, NFTService, OfferService, OnChainBidResponse, Onchain, QueryOptions, RedeemClaimableCodeData, RedeemClaimableCodeParam, RedeemEarnableCodeData, RedeemEarnableCodeParam, RedeemEarnableItemData, RedeemEarnableItemParam, RejectOfferData, RemoveListingData, RemoveListingParam, RemoveNFTFromFavoriteData, Response, SaveUserWalletSessionData, SaveUserWalletSessionParam, SignUpWithSignatureData, SignUpWithSignatureParam, SignatureService, SubmitProofOfApprovalData, SubmitProofOfApprovalParam, SubmitProofOfOfferData, SubmitProofOfOfferParam, TokenGatingService, TransferNFTData, TransferNFTParam, USDConversionData, UpdateApplicantData, UpdateApplicantParam, UpdateTokenListingData, UpdateTokenListingParam, UpdateTransactionHashData, UpdateTransactionHashParam, UpdateUserOrgSettingsData, UpdateUserOrgSettingsParam, UserService, VerifyOnChainBidParam, bubbleGumListArgParams, bubblegumMakeOfferArg, useAuction, useAuth, useClaims, useCollection, useConnectWallet, useConversion, useFee, useKYC, useListItem, useNFT, useOffer, useSignature, useTokenGating, useUser };