@oceanprotocol/lib 3.0.4 → 3.1.0

package/dist/src/contracts/SmartContractWithAddress.d.ts

@@ -1,17 +1,17 @@
-import { Signer, Contract } from 'ethers';
-import { AbiItem } from '../@types';
-import { Config } from '../config';
-import { SmartContract } from './SmartContract';
-export declare abstract class SmartContractWithAddress extends SmartContract {
-    address: string;
-    contract: Contract;
-    /**
-     * Instantiate the smart contract.
-     * @param {string} address The address of the contract.
-     * @param {Signer} signer The signer object.
-     * @param {string | number} network Network id or name
-     * @param {Config} config The configuration object.
-     * @param {AbiItem[]} abi ABI array of the smart contract
-     */
-    constructor(address: string, signer: Signer, network?: string | number, config?: Config, abi?: AbiItem[]);
-}
+import { Signer, Contract } from 'ethers';
+import { AbiItem } from '../@types';
+import { Config } from '../config';
+import { SmartContract } from './SmartContract';
+export declare abstract class SmartContractWithAddress extends SmartContract {
+    address: string;
+    contract: Contract;
+    /**
+     * Instantiate the smart contract.
+     * @param {string} address The address of the contract.
+     * @param {Signer} signer The signer object.
+     * @param {string | number} network Network id or name
+     * @param {Config} config The configuration object.
+     * @param {AbiItem[]} abi ABI array of the smart contract
+     */
+    constructor(address: string, signer: Signer, network?: string | number, config?: Config, abi?: AbiItem[]);
+}

package/dist/src/contracts/df/DfRewards.d.ts

@@ -1,31 +1,31 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { AbiItem, ReceiptOrEstimate } from '../../@types';
-/**
- * Provides an interface for DFRewards contract
- */
-export declare class DfRewards extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /** Get available DF Rewards for a token
-     * @param {String} userAddress user address
-     * @param {String} tokenAddress token address
-     * @return {Promise<string>}
-     */
-    getAvailableRewards(userAddress: string, tokenAddress: string): Promise<string>;
-    /**
-     * claim rewards for any address
-     * @param {String} userAddress user address to claim
-     * @param {String} tokenAddress token address
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    claimRewards<G extends boolean = false>(userAddress: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * allocate rewards to address.  An approve must exist before calling this function.
-     * @param {String[]} userAddresses array of users that will receive rewards
-     * @param {String[]} amounts array of amounts
-     * @param {String} tokenAddress token address
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    allocateRewards<G extends boolean = false>(userAddresses: string[], amounts: string[], tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { AbiItem, ReceiptOrEstimate } from '../../@types';
+/**
+ * Provides an interface for DFRewards contract
+ */
+export declare class DfRewards extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /** Get available DF Rewards for a token
+     * @param {String} userAddress user address
+     * @param {String} tokenAddress token address
+     * @return {Promise<string>}
+     */
+    getAvailableRewards(userAddress: string, tokenAddress: string): Promise<string>;
+    /**
+     * claim rewards for any address
+     * @param {String} userAddress user address to claim
+     * @param {String} tokenAddress token address
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimRewards<G extends boolean = false>(userAddress: string, tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * allocate rewards to address.  An approve must exist before calling this function.
+     * @param {String[]} userAddresses array of users that will receive rewards
+     * @param {String[]} amounts array of amounts
+     * @param {String} tokenAddress token address
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    allocateRewards<G extends boolean = false>(userAddresses: string[], amounts: string[], tokenAddress: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

package/dist/src/contracts/df/DfStrategyV1.d.ts

@@ -1,21 +1,21 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate, AbiItem } from '../../@types';
-/**
- * Provides an interface for dfStrategyV1 contract
- */
-export declare class DfStrategyV1 extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /** Get available DF Rewards for multiple tokens
-     * @param {String} userAddress user address
-     * @param {String} tokenAddresses array of tokens
-     * @return {Promise<string[]>}
-     */
-    getMultipleAvailableRewards(userAddress: string, tokenAddresses: string[]): Promise<string[]>;
-    /**
-     * claim multiple token rewards for any address
-     * @param {String} userAddress user address to claim
-     * @param {String} tokenAddresses array of tokens
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    claimMultipleRewards<G extends boolean = false>(userAddress: string, tokenAddresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for dfStrategyV1 contract
+ */
+export declare class DfStrategyV1 extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /** Get available DF Rewards for multiple tokens
+     * @param {String} userAddress user address
+     * @param {String} tokenAddresses array of tokens
+     * @return {Promise<string[]>}
+     */
+    getMultipleAvailableRewards(userAddress: string, tokenAddresses: string[]): Promise<string[]>;
+    /**
+     * claim multiple token rewards for any address
+     * @param {String} userAddress user address to claim
+     * @param {String} tokenAddresses array of tokens
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimMultipleRewards<G extends boolean = false>(userAddress: string, tokenAddresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

package/dist/src/contracts/index.d.ts

@@ -1,14 +1,14 @@
-export * from './SmartContract';
-export * from './SmartContractWithAddress';
-export * from './Dispenser';
-export * from './FixedRateExchange';
-export * from './Router';
-export * from './Datatoken';
-export * from './NFT';
-export * from './NFTFactory';
-export * from './ve/VeOcean';
-export * from './ve/VeFeeDistributor';
-export * from './ve/VeFeeEstimate';
-export * from './ve/VeAllocate';
-export * from './df/DfRewards';
-export * from './df/DfStrategyV1';
+export * from './SmartContract';
+export * from './SmartContractWithAddress';
+export * from './Dispenser';
+export * from './FixedRateExchange';
+export * from './Router';
+export * from './Datatoken';
+export * from './NFT';
+export * from './NFTFactory';
+export * from './ve/VeOcean';
+export * from './ve/VeFeeDistributor';
+export * from './ve/VeFeeEstimate';
+export * from './ve/VeAllocate';
+export * from './df/DfRewards';
+export * from './df/DfStrategyV1';

package/dist/src/contracts/ve/VeAllocate.d.ts

@@ -1,38 +1,38 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate, AbiItem } from '../../@types';
-/**
- * Provides an interface for veOcean contract
- */
-export declare class VeAllocate extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /**
-     * set a specific percentage of veOcean to a specific nft
-     * Maximum allocated percentage is 10000, so 1% is specified as 100
-     * @param {String} amount Percentage used
-     * @param {String} nft NFT address to allocate to
-     * @param {String} chainId chainId of NFT
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    setAllocation<G extends boolean = false>(amount: string, nft: string, chainId: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * set specific percetage of veOcean to multiple nfts
-     * Maximum allocated percentage is 10000, so 1% is specified as 100
-     * @param {String[]} amount Array of percentages used
-     * @param {String[]} nft Array of NFT addresses
-     * @param {String[]} chainId Array of chainIds
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    setBatchAllocation<G extends boolean = false>(amount: string[], nft: string[], chainId: number[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /** Get totalAllocation for address
-     * @param {String} userAddress user address
-     * @return {Promise<number>}
-     */
-    getTotalAllocation(userAddress: string): Promise<number>;
-    /** Get getveAllocation for address, nft, chainId
-     * @param {String} userAddress user address
-     * @param {String} nft NFT address to allocate to
-     * @param {String} chainId chainId of NFT
-     * @return {Promise<number>}
-     */
-    getVeAllocation(userAddress: string, nft: string, chainId: string): Promise<number>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeAllocate extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * set a specific percentage of veOcean to a specific nft
+     * Maximum allocated percentage is 10000, so 1% is specified as 100
+     * @param {String} amount Percentage used
+     * @param {String} nft NFT address to allocate to
+     * @param {String} chainId chainId of NFT
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    setAllocation<G extends boolean = false>(amount: string, nft: string, chainId: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * set specific percetage of veOcean to multiple nfts
+     * Maximum allocated percentage is 10000, so 1% is specified as 100
+     * @param {String[]} amount Array of percentages used
+     * @param {String[]} nft Array of NFT addresses
+     * @param {String[]} chainId Array of chainIds
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    setBatchAllocation<G extends boolean = false>(amount: string[], nft: string[], chainId: number[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get totalAllocation for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    getTotalAllocation(userAddress: string): Promise<number>;
+    /** Get getveAllocation for address, nft, chainId
+     * @param {String} userAddress user address
+     * @param {String} nft NFT address to allocate to
+     * @param {String} chainId chainId of NFT
+     * @return {Promise<number>}
+     */
+    getVeAllocation(userAddress: string, nft: string, chainId: string): Promise<number>;
+}

package/dist/src/contracts/ve/VeFeeDistributor.d.ts

@@ -1,29 +1,29 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate, AbiItem } from '../../@types';
-/**
- * Provides an interface for veOcean contract
- */
-export declare class VeFeeDistributor extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /**
-     * Claim fees for `userAddress`
-     * Each call to claim look at a maximum of 50 user veOCEAN points.
-           For accounts with many veOCEAN related actions, this function
-           may need to be called more than once to claim all available
-           fees. In the `Claimed` event that fires, if `claim_epoch` is
-           less than `max_epoch`, the account may claim again
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    claim<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * Make multiple fee claims in a single call
-      Used to claim for many accounts at once, or to make
-           multiple claims for the same address when that address
-           has significant veOCEAN history
-     * @param {String} addresses array of addresses to claim
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    claimMany<G extends boolean = false>(addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeFeeDistributor extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * Claim fees for `userAddress`
+     * Each call to claim look at a maximum of 50 user veOCEAN points.
+           For accounts with many veOCEAN related actions, this function
+           may need to be called more than once to claim all available
+           fees. In the `Claimed` event that fires, if `claim_epoch` is
+           less than `max_epoch`, the account may claim again
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claim<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Make multiple fee claims in a single call
+      Used to claim for many accounts at once, or to make
+           multiple claims for the same address when that address
+           has significant veOCEAN history
+     * @param {String} addresses array of addresses to claim
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    claimMany<G extends boolean = false>(addresses: string[], estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+}

package/dist/src/contracts/ve/VeFeeEstimate.d.ts

@@ -1,14 +1,14 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { AbiItem } from '../../@types';
-/**
- * Provides an interface for veOcean contract
- */
-export declare class VeFeeEstimate extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /**
-     * estimateClaim
-     * @param {String} userAddress user address
-     * @return {Promise<string>}
-     */
-    estimateClaim(userAddress: string): Promise<string>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeFeeEstimate extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * estimateClaim
+     * @param {String} userAddress user address
+     * @return {Promise<string>}
+     */
+    estimateClaim(userAddress: string): Promise<string>;
+}

package/dist/src/contracts/ve/VeOcean.d.ts

@@ -1,68 +1,68 @@
-import { SmartContractWithAddress } from '../SmartContractWithAddress';
-import { ReceiptOrEstimate, AbiItem } from '../../@types';
-/**
- * Provides an interface for veOcean contract
- */
-export declare class VeOcean extends SmartContractWithAddress {
-    getDefaultAbi(): AbiItem[];
-    /**
-     * Deposit `amount` tokens for `userAddress` and lock until `unlockTime`
-     * @param {String} amount Amount of tokens to be locked
-     * @param {Number} unlockTime Timestamp for unlock
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    lockTokens<G extends boolean = false>(amount: string, unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * Deposit `amount` tokens for `toAddress` and add to the existing lock
-     * Anyone (even a smart contract) can deposit for someone else, but cannot extend their locktime and deposit for a brand new user
-     * @param {String} toAddress user address to deposit for
-     * @param {String} amount Amount of tokens to be locked
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    depositFor<G extends boolean = false>(toAddress: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * Deposit `amount` additional tokens for `userAddress` without modifying the unlock time
-     * @param {String} amount Amount of tokens to be locked
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    increaseAmount<G extends boolean = false>(amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * Extend the unlock time for `userAddress` to `unlockTime`
-     * @param {Number} unlockTime Timestamp for new unlock time
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    increaseUnlockTime<G extends boolean = false>(unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /**
-     * Withdraw all tokens for `userAddress`
-     * @param {Boolean} estimateGas if True, return gas estimate
-     * @return {Promise<ReceiptOrEstimate>}
-     */
-    withdraw<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
-    /** Get voting power for address
-     * @param {String} userAddress user address
-     * @return {Promise<number>}
-     */
-    getVotingPower(userAddress: string): Promise<number>;
-    /** Get locked balance
-     * @param {String} userAddress user address
-     * @return {Promise<string>}
-     */
-    getLockedAmount(userAddress: string): Promise<string>;
-    /** Get untilLock for address
-     * @param {String} userAddress user address
-     * @return {Promise<number>}
-     */
-    lockEnd(userAddress: string): Promise<number>;
-    /** Get total supply
-     * @return {Promise<number>}
-     */
-    totalSupply(): Promise<string>;
-    /** Get token
-     * @return {Promise<string>}
-     */
-    getToken(): Promise<string>;
-}
+import { SmartContractWithAddress } from '../SmartContractWithAddress';
+import { ReceiptOrEstimate, AbiItem } from '../../@types';
+/**
+ * Provides an interface for veOcean contract
+ */
+export declare class VeOcean extends SmartContractWithAddress {
+    getDefaultAbi(): AbiItem[];
+    /**
+     * Deposit `amount` tokens for `userAddress` and lock until `unlockTime`
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Number} unlockTime Timestamp for unlock
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    lockTokens<G extends boolean = false>(amount: string, unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deposit `amount` tokens for `toAddress` and add to the existing lock
+     * Anyone (even a smart contract) can deposit for someone else, but cannot extend their locktime and deposit for a brand new user
+     * @param {String} toAddress user address to deposit for
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    depositFor<G extends boolean = false>(toAddress: string, amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Deposit `amount` additional tokens for `userAddress` without modifying the unlock time
+     * @param {String} amount Amount of tokens to be locked
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseAmount<G extends boolean = false>(amount: string, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Extend the unlock time for `userAddress` to `unlockTime`
+     * @param {Number} unlockTime Timestamp for new unlock time
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    increaseUnlockTime<G extends boolean = false>(unlockTime: number, estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /**
+     * Withdraw all tokens for `userAddress`
+     * @param {Boolean} estimateGas if True, return gas estimate
+     * @return {Promise<ReceiptOrEstimate>}
+     */
+    withdraw<G extends boolean = false>(estimateGas?: G): Promise<ReceiptOrEstimate<G>>;
+    /** Get voting power for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    getVotingPower(userAddress: string): Promise<number>;
+    /** Get locked balance
+     * @param {String} userAddress user address
+     * @return {Promise<string>}
+     */
+    getLockedAmount(userAddress: string): Promise<string>;
+    /** Get untilLock for address
+     * @param {String} userAddress user address
+     * @return {Promise<number>}
+     */
+    lockEnd(userAddress: string): Promise<number>;
+    /** Get total supply
+     * @return {Promise<number>}
+     */
+    totalSupply(): Promise<string>;
+    /** Get token
+     * @return {Promise<string>}
+     */
+    getToken(): Promise<string>;
+}

package/dist/src/index.d.ts

@@ -1,5 +1,5 @@
-export * from './@types';
-export * from './config';
-export * from './contracts';
-export * from './services';
-export * from './utils';
+export * from './@types';
+export * from './config';
+export * from './contracts';
+export * from './services';
+export * from './utils';

package/dist/src/services/Aquarius.d.ts

@@ -1,53 +1,53 @@
-import { Asset, DDO, ValidateMetadata } from '../@types';
-export interface SearchQuery {
-    from?: number;
-    size?: number;
-    query: any;
-    sort?: {
-        [jsonPath: string]: string;
-    };
-    aggs?: any;
-}
-export declare class Aquarius {
-    aquariusURL: string;
-    /**
-     * Instantiate Aquarius
-     * @param {String} aquariusURL
-     */
-    constructor(aquariusURL: string);
-    /** Resolves a DID
-     * @param {string} did DID of the asset.
-     * @param {AbortSignal} signal abort signal
-     * @return {Promise<Asset>} Asset
-     */
-    resolve(did: string, signal?: AbortSignal): Promise<Asset>;
-    /**
-     * Blocks until Aqua will cache the did (or the update for that did) or timeouts
-     * @param {string} did DID of the asset.
-     * @param {string} txid used when the did exists and we expect an update with that txid.
-     * @param {AbortSignal} signal abort signal
-     * @return {Promise<Asset>} DDO of the asset.
-     */
-    waitForAqua(did: string, txid?: string, signal?: AbortSignal): Promise<Asset>;
-    /**
-     * Validate DDO content
-     * @param {DDO} ddo DID Descriptor Object content.
-     * @param {AbortSignal} signal abort signal
-     * @return {Promise<ValidateMetadata>}.
-     */
-    validate(ddo: DDO, signal?: AbortSignal): Promise<ValidateMetadata>;
-    /**
-     * Search over the DDOs using a query.
-     * @param {string} did DID of the asset
-     * @param {AbortSignal} signal abort signal
-     * @return {Promise<QueryResult>}
-     */
-    getAssetMetadata(did: string, signal?: AbortSignal): Promise<any>;
-    /**
-     * Search over the DDOs using a query.
-     * @param  {SearchQuery} query Query to filter the DDOs.
-     * @param {AbortSignal} signal abort signal
-     * @return {Promise<QueryResult>}
-     */
-    querySearch(query: SearchQuery, signal?: AbortSignal): Promise<any>;
-}
+import { Asset, DDO, ValidateMetadata } from '../@types';
+export interface SearchQuery {
+    from?: number;
+    size?: number;
+    query: any;
+    sort?: {
+        [jsonPath: string]: string;
+    };
+    aggs?: any;
+}
+export declare class Aquarius {
+    aquariusURL: string;
+    /**
+     * Instantiate Aquarius
+     * @param {String} aquariusURL
+     */
+    constructor(aquariusURL: string);
+    /** Resolves a DID
+     * @param {string} did DID of the asset.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<Asset>} Asset
+     */
+    resolve(did: string, signal?: AbortSignal): Promise<Asset>;
+    /**
+     * Blocks until Aqua will cache the did (or the update for that did) or timeouts
+     * @param {string} did DID of the asset.
+     * @param {string} txid used when the did exists and we expect an update with that txid.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<Asset>} DDO of the asset.
+     */
+    waitForAqua(did: string, txid?: string, signal?: AbortSignal): Promise<Asset>;
+    /**
+     * Validate DDO content
+     * @param {DDO} ddo DID Descriptor Object content.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<ValidateMetadata>}.
+     */
+    validate(ddo: DDO, signal?: AbortSignal): Promise<ValidateMetadata>;
+    /**
+     * Search over the DDOs using a query.
+     * @param {string} did DID of the asset
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<QueryResult>}
+     */
+    getAssetMetadata(did: string, signal?: AbortSignal): Promise<any>;
+    /**
+     * Search over the DDOs using a query.
+     * @param  {SearchQuery} query Query to filter the DDOs.
+     * @param {AbortSignal} signal abort signal
+     * @return {Promise<QueryResult>}
+     */
+    querySearch(query: SearchQuery, signal?: AbortSignal): Promise<any>;
+}