@alephium/web3 2.0.10 → 3.0.0-test.1

package/dist/_cjs/api/api-alephium.d.ts

@@ -0,0 +1,1152 @@
+export interface AddressAssetState {
+    address: string;
+    attoAlphAmount: string;
+    tokens?: Token[];
+}
+export interface AddressBalance {
+    address: string;
+    balance: string;
+    balanceHint: string;
+    lockedBalance: string;
+    lockedBalanceHint: string;
+}
+export interface AddressInfo {
+    address: string;
+    publicKey: string;
+    group: number;
+    path: string;
+}
+export interface Addresses {
+    activeAddress: string;
+    addresses: AddressInfo[];
+}
+export interface AssetInput {
+    outputRef: OutputRef;
+    unlockScript: string;
+}
+export interface AssetOutput {
+    hint: number;
+    key: string;
+    attoAlphAmount: string;
+    address: string;
+    tokens: Token[];
+    lockTime: number;
+    message: string;
+    type: string;
+}
+export interface AssetState {
+    attoAlphAmount: string;
+    tokens?: Token[];
+}
+export interface BadRequest {
+    detail: string;
+}
+export interface Balance {
+    balance: string;
+    balanceHint: string;
+    lockedBalance: string;
+    lockedBalanceHint: string;
+    tokenBalances?: Token[];
+    lockedTokenBalances?: Token[];
+    utxoNum: number;
+}
+export interface Balances {
+    totalBalance: string;
+    totalBalanceHint: string;
+    balances: AddressBalance[];
+}
+export interface Ban {
+    peers: string[];
+    type: string;
+}
+export interface Banned {
+    until: number;
+    type: string;
+}
+export interface BlockAndEvents {
+    block: BlockEntry;
+    events: ContractEventByBlockHash[];
+}
+export interface BlockEntry {
+    hash: string;
+    timestamp: number;
+    chainFrom: number;
+    chainTo: number;
+    height: number;
+    deps: string[];
+    transactions: Transaction[];
+    nonce: string;
+    version: number;
+    depStateHash: string;
+    txsHash: string;
+    target: string;
+    ghostUncles: GhostUncleBlockEntry[];
+    conflictedTxs?: string[];
+}
+export interface BlockHeaderEntry {
+    hash: string;
+    timestamp: number;
+    chainFrom: number;
+    chainTo: number;
+    height: number;
+    deps: string[];
+}
+export interface BlocksAndEventsPerTimeStampRange {
+    blocksAndEvents: BlockAndEvents[][];
+}
+export interface BlocksPerTimeStampRange {
+    blocks: BlockEntry[][];
+}
+export interface BrokerInfo {
+    cliqueId: string;
+    brokerId: number;
+    brokerNum: number;
+    address: {
+        addr: string;
+        port: number;
+    };
+}
+export interface BuildChainedDeployContractTx {
+    value: BuildDeployContractTx;
+    type: string;
+}
+export interface BuildChainedDeployContractTxResult {
+    value: BuildSimpleDeployContractTxResult;
+    type: string;
+}
+export interface BuildChainedExecuteScriptTx {
+    value: BuildExecuteScriptTx;
+    type: string;
+}
+export interface BuildChainedExecuteScriptTxResult {
+    value: BuildSimpleExecuteScriptTxResult;
+    type: string;
+}
+export interface BuildChainedTransferTx {
+    value: BuildTransferTx;
+    type: string;
+}
+export interface BuildChainedTransferTxResult {
+    value: BuildSimpleTransferTxResult;
+    type: string;
+}
+export type BuildChainedTx = BuildChainedDeployContractTx | BuildChainedExecuteScriptTx | BuildChainedTransferTx;
+export type BuildChainedTxResult = BuildChainedDeployContractTxResult | BuildChainedExecuteScriptTxResult | BuildChainedTransferTxResult;
+export interface BuildDeployContractTx {
+    fromPublicKey: string;
+    fromPublicKeyType?: string;
+    bytecode: string;
+    initialAttoAlphAmount?: string;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: string;
+    issueTokenTo?: string;
+    gasAmount?: number;
+    gasPrice?: string;
+    group?: number;
+    targetBlockHash?: string;
+}
+export type BuildDeployContractTxResult = BuildGrouplessDeployContractTxResult | BuildSimpleDeployContractTxResult;
+export interface BuildExecuteScriptTx {
+    fromPublicKey: string;
+    fromPublicKeyType?: string;
+    bytecode: string;
+    attoAlphAmount?: string;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: string;
+    targetBlockHash?: string;
+    group?: number;
+    gasEstimationMultiplier?: number;
+    dustAmount?: string;
+}
+export type BuildExecuteScriptTxResult = BuildGrouplessExecuteScriptTxResult | BuildSimpleExecuteScriptTxResult;
+export interface BuildGrouplessDeployContractTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    contractAddress: string;
+    fundingTxs?: BuildSimpleTransferTxResult[];
+}
+export interface BuildGrouplessExecuteScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    simulationResult: SimulationResult;
+    fundingTxs?: BuildSimpleTransferTxResult[];
+}
+export interface BuildGrouplessTransferTxResult {
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+    fundingTxs?: BuildSimpleTransferTxResult[];
+}
+export interface BuildInfo {
+    releaseVersion: string;
+    commit: string;
+}
+export interface BuildMultiAddressesTransaction {
+    from: Source[];
+    gasPrice?: string;
+    targetBlockHash?: string;
+}
+export interface BuildMultisig {
+    fromAddress: string;
+    fromPublicKeys: string[];
+    fromPublicKeyTypes?: string[];
+    fromPublicKeyIndexes?: number[];
+    destinations: Destination[];
+    gas?: number;
+    gasPrice?: string;
+    group?: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
+}
+export interface BuildMultisigAddress {
+    keys: string[];
+    keyTypes?: string[];
+    mrequired: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
+}
+export interface BuildMultisigAddressResult {
+    address: string;
+}
+export interface BuildSimpleDeployContractTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    contractAddress: string;
+}
+export interface BuildSimpleExecuteScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    simulationResult: SimulationResult;
+}
+export interface BuildSimpleTransferTxResult {
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export interface BuildSweepAddressTransactions {
+    fromPublicKey: string;
+    fromPublicKeyType?: string;
+    toAddress: string;
+    maxAttoAlphPerUTXO?: string;
+    lockTime?: number;
+    gasAmount?: number;
+    gasPrice?: string;
+    targetBlockHash?: string;
+    utxosLimit?: number;
+    group?: number;
+    sweepAlphOnly?: boolean;
+}
+export interface BuildSweepAddressTransactionsResult {
+    unsignedTxs: SweepAddressTransaction[];
+    fromGroup: number;
+    toGroup: number;
+}
+export interface BuildSweepMultisig {
+    fromAddress: string;
+    fromPublicKeys: string[];
+    fromPublicKeyTypes?: string[];
+    fromPublicKeyIndexes?: number[];
+    toAddress: string;
+    maxAttoAlphPerUTXO?: string;
+    lockTime?: number;
+    gasAmount?: number;
+    gasPrice?: string;
+    utxosLimit?: number;
+    targetBlockHash?: string;
+    group?: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
+    sweepAlphOnly?: boolean;
+}
+export interface BuildTransferTx {
+    fromPublicKey: string;
+    fromPublicKeyType?: string;
+    destinations: Destination[];
+    utxos?: OutputRef[];
+    gasAmount?: number;
+    gasPrice?: string;
+    group?: number;
+    targetBlockHash?: string;
+}
+export type BuildTransferTxResult = BuildGrouplessTransferTxResult | BuildSimpleTransferTxResult;
+export interface CallContract {
+    group: number;
+    worldStateBlockHash?: string;
+    txId?: string;
+    address: string;
+    callerAddress?: string;
+    methodIndex: number;
+    args?: Val[];
+    interestedContracts?: string[];
+    inputAssets?: TestInputAsset[];
+}
+export interface CallContractFailed {
+    error: string;
+    type: string;
+}
+export type CallContractResult = CallContractFailed | CallContractSucceeded;
+export interface CallContractSucceeded {
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txInputs: string[];
+    txOutputs: Output[];
+    events: ContractEventByTxId[];
+    debugMessages: DebugMessage[];
+    type: string;
+}
+export interface CallTxScript {
+    group: number;
+    bytecode: string;
+    callerAddress?: string;
+    worldStateBlockHash?: string;
+    txId?: string;
+    inputAssets?: TestInputAsset[];
+    interestedContracts?: string[];
+}
+export interface CallTxScriptResult {
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txInputs: string[];
+    txOutputs: Output[];
+    events: ContractEventByTxId[];
+    debugMessages: DebugMessage[];
+}
+export interface ChainInfo {
+    currentHeight: number;
+}
+export interface ChainParams {
+    networkId: number;
+    numZerosAtLeastInHash: number;
+    groupNumPerBroker: number;
+    groups: number;
+}
+export interface ChangeActiveAddress {
+    address: string;
+}
+export interface CompileContractResult {
+    version: string;
+    name: string;
+    bytecode: string;
+    bytecodeDebugPatch: string;
+    codeHash: string;
+    codeHashDebug: string;
+    fields: FieldsSig;
+    functions: FunctionSig[];
+    constants: Constant[];
+    enums: Enum[];
+    events: EventSig[];
+    warnings: string[];
+    maps?: MapsSig;
+    stdInterfaceId?: string;
+}
+export interface CompileProjectResult {
+    contracts: CompileContractResult[];
+    scripts: CompileScriptResult[];
+    structs?: StructSig[];
+    constants?: Constant[];
+    enums?: Enum[];
+    warnings?: string[];
+    testError?: string;
+}
+export interface CompileScriptResult {
+    version: string;
+    name: string;
+    bytecodeTemplate: string;
+    bytecodeDebugPatch: string;
+    fields: FieldsSig;
+    functions: FunctionSig[];
+    warnings: string[];
+}
+export interface CompilerOptions {
+    ignoreUnusedConstantsWarnings?: boolean;
+    ignoreUnusedVariablesWarnings?: boolean;
+    ignoreUnusedFieldsWarnings?: boolean;
+    ignoreUnusedPrivateFunctionsWarnings?: boolean;
+    ignoreUpdateFieldsCheckWarnings?: boolean;
+    ignoreCheckExternalCallerWarnings?: boolean;
+    ignoreUnusedFunctionReturnWarnings?: boolean;
+    skipAbstractContractCheck?: boolean;
+    skipTests?: boolean;
+}
+export interface Confirmed {
+    blockHash: string;
+    txIndex: number;
+    chainConfirmations: number;
+    fromGroupConfirmations: number;
+    toGroupConfirmations: number;
+    type: string;
+}
+export interface Conflicted {
+    blockHash: string;
+    txIndex: number;
+    chainConfirmations: number;
+    fromGroupConfirmations: number;
+    toGroupConfirmations: number;
+    type: string;
+}
+export interface Constant {
+    name: string;
+    value: Val;
+}
+export interface Contract {
+    code: string;
+    compilerOptions?: CompilerOptions;
+}
+export interface ContractEvent {
+    blockHash: string;
+    txId: string;
+    eventIndex: number;
+    fields: Val[];
+}
+export interface ContractEventByBlockHash {
+    txId: string;
+    contractAddress: string;
+    eventIndex: number;
+    fields: Val[];
+}
+export interface ContractEventByTxId {
+    blockHash: string;
+    contractAddress: string;
+    eventIndex: number;
+    fields: Val[];
+}
+export interface ContractEvents {
+    events: ContractEvent[];
+    nextStart: number;
+}
+export interface ContractEventsByBlockHash {
+    events: ContractEventByBlockHash[];
+}
+export interface ContractEventsByTxId {
+    events: ContractEventByTxId[];
+}
+export interface ContractOutput {
+    hint: number;
+    key: string;
+    attoAlphAmount: string;
+    address: string;
+    tokens: Token[];
+    type: string;
+}
+export interface ContractState {
+    address: string;
+    bytecode: string;
+    codeHash: string;
+    initialStateHash?: string;
+    immFields: Val[];
+    mutFields: Val[];
+    asset: AssetState;
+}
+export interface CurrentDifficulty {
+    difficulty: string;
+}
+export interface DebugMessage {
+    contractAddress: string;
+    message: string;
+}
+export interface DecodeUnsignedTx {
+    unsignedTx: string;
+}
+export interface DecodeUnsignedTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: UnsignedTx;
+}
+export interface Destination {
+    address: string;
+    attoAlphAmount?: string;
+    tokens?: Token[];
+    lockTime?: number;
+    message?: string;
+}
+export type DiscoveryAction = Reachable | Unreachable;
+export interface Enum {
+    name: string;
+    fields: EnumField[];
+}
+export interface EnumField {
+    name: string;
+    value: Val;
+}
+export interface EventSig {
+    name: string;
+    fieldNames: string[];
+    fieldTypes: string[];
+}
+export interface FieldsSig {
+    names: string[];
+    types: string[];
+    isMutable: boolean[];
+}
+export interface FixedAssetOutput {
+    hint: number;
+    key: string;
+    attoAlphAmount: string;
+    address: string;
+    tokens: Token[];
+    lockTime: number;
+    message: string;
+}
+export interface FunctionSig {
+    name: string;
+    usePreapprovedAssets: boolean;
+    useAssetsInContract: boolean;
+    isPublic: boolean;
+    paramNames: string[];
+    paramTypes: string[];
+    paramIsMutable: boolean[];
+    returnTypes: string[];
+}
+export interface GatewayTimeout {
+    detail: string;
+}
+export interface GhostUncleBlockEntry {
+    blockHash: string;
+    miner: string;
+}
+export interface Group {
+    group: number;
+}
+export interface HashRateResponse {
+    hashrate: string;
+}
+export interface HashesAtHeight {
+    headers: string[];
+}
+export interface InterCliquePeerInfo {
+    cliqueId: string;
+    brokerId: number;
+    groupNumPerBroker: number;
+    address: {
+        addr: string;
+        port: number;
+    };
+    isSynced: boolean;
+    clientVersion: string;
+}
+export interface InternalServerError {
+    detail: string;
+}
+export interface MapsSig {
+    names: string[];
+    types: string[];
+}
+export interface MemPooled {
+    type: string;
+}
+export interface MempoolTransactions {
+    fromGroup: number;
+    toGroup: number;
+    transactions: TransactionTemplate[];
+}
+export interface MinerAddresses {
+    addresses: string[];
+}
+export interface MinerAddressesInfo {
+    addresses: AddressInfo[];
+}
+export type MisbehaviorAction = Ban | Unban;
+export interface MultipleCallContract {
+    calls: CallContract[];
+}
+export interface MultipleCallContractResult {
+    results: CallContractResult[];
+}
+export interface NodeInfo {
+    buildInfo: BuildInfo;
+    upnp: boolean;
+    externalAddress?: {
+        addr: string;
+        port: number;
+    };
+}
+export interface NodeVersion {
+    version: string;
+}
+export interface NotFound {
+    detail: string;
+    resource: string;
+}
+export type Output = AssetOutput | ContractOutput;
+export interface OutputRef {
+    hint: number;
+    key: string;
+}
+export interface PeerAddress {
+    address: string;
+    restPort: number;
+    wsPort: number;
+    minerApiPort: number;
+}
+export interface PeerMisbehavior {
+    peer: string;
+    status: PeerStatus;
+}
+export type PeerStatus = Banned | Penalty;
+export interface Penalty {
+    value: number;
+    type: string;
+}
+export interface Project {
+    code: string;
+    compilerOptions?: CompilerOptions;
+}
+export interface RawBlock {
+    value: string;
+}
+export interface RawTransaction {
+    value: string;
+}
+export interface Reachable {
+    peers: string[];
+    type: string;
+}
+export interface Result {
+    hashrate: string;
+}
+export interface RevealMnemonic {
+    password: string;
+}
+export interface RevealMnemonicResult {
+    mnemonic: string;
+}
+export interface RichAssetInput {
+    hint: number;
+    key: string;
+    unlockScript: string;
+    attoAlphAmount: string;
+    address: string;
+    tokens: Token[];
+    outputRefTxId: string;
+}
+export interface RichBlockAndEvents {
+    block: RichBlockEntry;
+    events: ContractEventByBlockHash[];
+}
+export interface RichBlockEntry {
+    hash: string;
+    timestamp: number;
+    chainFrom: number;
+    chainTo: number;
+    height: number;
+    deps: string[];
+    transactions: RichTransaction[];
+    nonce: string;
+    version: number;
+    depStateHash: string;
+    txsHash: string;
+    target: string;
+    ghostUncles: GhostUncleBlockEntry[];
+    conflictedTxs?: string[];
+}
+export interface RichBlocksAndEventsPerTimeStampRange {
+    blocksAndEvents: RichBlockAndEvents[][];
+}
+export interface RichContractInput {
+    hint: number;
+    key: string;
+    attoAlphAmount: string;
+    address: string;
+    tokens: Token[];
+    outputRefTxId: string;
+}
+export interface RichTransaction {
+    unsigned: RichUnsignedTx;
+    scriptExecutionOk: boolean;
+    contractInputs: RichContractInput[];
+    generatedOutputs: Output[];
+    inputSignatures: string[];
+    scriptSignatures: string[];
+}
+export interface RichUnsignedTx {
+    txId: string;
+    version: number;
+    networkId: number;
+    scriptOpt?: string;
+    gasAmount: number;
+    gasPrice: string;
+    inputs: RichAssetInput[];
+    fixedOutputs: FixedAssetOutput[];
+}
+export interface Script {
+    code: string;
+    compilerOptions?: CompilerOptions;
+}
+export interface SelfClique {
+    cliqueId: string;
+    nodes: PeerAddress[];
+    selfReady: boolean;
+    synced: boolean;
+}
+export interface ServiceUnavailable {
+    detail: string;
+}
+export interface Sign {
+    data: string;
+}
+export interface SignResult {
+    signature: string;
+}
+export interface SimulationResult {
+    contractInputs: AddressAssetState[];
+    generatedOutputs: AddressAssetState[];
+}
+export interface Source {
+    fromPublicKey: string;
+    destinations: Destination[];
+    fromPublicKeyType?: string;
+    gasAmount?: number;
+    utxos?: OutputRef[];
+}
+export interface StructSig {
+    name: string;
+    fieldNames: string[];
+    fieldTypes: string[];
+    isMutable: boolean[];
+}
+export interface SubContracts {
+    subContracts: string[];
+    nextStart: number;
+}
+export interface SubmitMultisig {
+    unsignedTx: string;
+    signatures: string[];
+}
+export interface SubmitTransaction {
+    unsignedTx: string;
+    signature: string;
+}
+export interface SubmitTxResult {
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export interface Sweep {
+    toAddress: string;
+    lockTime?: number;
+    gasAmount?: number;
+    gasPrice?: string;
+    utxosLimit?: number;
+    targetBlockHash?: string;
+}
+export interface SweepAddressTransaction {
+    txId: string;
+    unsignedTx: string;
+    gasAmount: number;
+    gasPrice: string;
+}
+export interface TargetToHashrate {
+    target: string;
+}
+export interface TestContract {
+    group?: number;
+    blockHash?: string;
+    blockTimeStamp?: number;
+    txId?: string;
+    address?: string;
+    callerContractAddress?: string;
+    bytecode: string;
+    initialImmFields?: Val[];
+    initialMutFields?: Val[];
+    initialAsset?: AssetState;
+    methodIndex?: number;
+    args?: Val[];
+    existingContracts?: ContractState[];
+    inputAssets?: TestInputAsset[];
+    dustAmount?: string;
+}
+export interface TestContractResult {
+    address: string;
+    codeHash: string;
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txInputs: string[];
+    txOutputs: Output[];
+    events: ContractEventByTxId[];
+    debugMessages: DebugMessage[];
+}
+export interface TestInputAsset {
+    address: string;
+    asset: AssetState;
+}
+export interface Token {
+    id: string;
+    amount: string;
+}
+export interface Transaction {
+    unsigned: UnsignedTx;
+    scriptExecutionOk: boolean;
+    contractInputs: OutputRef[];
+    generatedOutputs: Output[];
+    inputSignatures: string[];
+    scriptSignatures: string[];
+}
+export interface TransactionTemplate {
+    unsigned: UnsignedTx;
+    inputSignatures: string[];
+    scriptSignatures: string[];
+    seenAt: number;
+}
+export interface Transfer {
+    destinations: Destination[];
+    gas?: number;
+    gasPrice?: string;
+    utxosLimit?: number;
+}
+export interface TransferResult {
+    txId: string;
+    fromGroup: number;
+    toGroup: number;
+}
+export interface TransferResults {
+    results: TransferResult[];
+}
+export interface TxNotFound {
+    type: string;
+}
+export type TxStatus = Confirmed | Conflicted | MemPooled | TxNotFound;
+export interface UTXO {
+    ref: OutputRef;
+    amount: string;
+    tokens?: Token[];
+    lockTime?: number;
+    additionalData?: string;
+}
+export interface UTXOs {
+    utxos: UTXO[];
+}
+export interface Unauthorized {
+    detail: string;
+}
+export interface Unban {
+    peers: string[];
+    type: string;
+}
+export interface Unreachable {
+    peers: string[];
+    type: string;
+}
+export interface UnsignedTx {
+    txId: string;
+    version: number;
+    networkId: number;
+    scriptOpt?: string;
+    gasAmount: number;
+    gasPrice: string;
+    inputs: AssetInput[];
+    fixedOutputs: FixedAssetOutput[];
+}
+export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256;
+export interface ValAddress {
+    value: string;
+    type: string;
+}
+export interface ValArray {
+    value: Val[];
+    type: string;
+}
+export interface ValBool {
+    value: boolean;
+    type: string;
+}
+export interface ValByteVec {
+    value: string;
+    type: string;
+}
+export interface ValI256 {
+    value: string;
+    type: string;
+}
+export interface ValU256 {
+    value: string;
+    type: string;
+}
+export interface VerifySignature {
+    data: string;
+    signature: string;
+    publicKey: string;
+}
+export interface WalletCreation {
+    password: string;
+    walletName: string;
+    isMiner?: boolean;
+    mnemonicPassphrase?: string;
+    mnemonicSize?: number;
+}
+export interface WalletCreationResult {
+    walletName: string;
+    mnemonic: string;
+}
+export interface WalletRestore {
+    password: string;
+    mnemonic: string;
+    walletName: string;
+    isMiner?: boolean;
+    mnemonicPassphrase?: string;
+}
+export interface WalletRestoreResult {
+    walletName: string;
+}
+export interface WalletStatus {
+    walletName: string;
+    locked: boolean;
+}
+export interface WalletUnlock {
+    password: string;
+    mnemonicPassphrase?: string;
+}
+export type QueryParamsType = Record<string | number, any>;
+export type ResponseFormat = keyof Omit<Body, 'body' | 'bodyUsed'>;
+export interface FullRequestParams extends Omit<RequestInit, 'body'> {
+    secure?: boolean;
+    path: string;
+    type?: ContentType;
+    query?: QueryParamsType;
+    format?: ResponseFormat;
+    body?: unknown;
+    baseUrl?: string;
+    cancelToken?: CancelToken;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> {
+    baseUrl?: string;
+    baseApiParams?: Omit<RequestParams, 'baseUrl' | 'cancelToken' | 'signal'>;
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<RequestParams | void> | RequestParams | void;
+    customFetch?: typeof fetch;
+}
+export interface HttpResponse<D extends unknown, E extends unknown = unknown> extends Response {
+    data: D;
+    error: E;
+}
+type CancelToken = Symbol | string | number;
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    baseUrl: string;
+    private securityData;
+    private securityWorker?;
+    private abortControllers;
+    private customFetch;
+    private baseApiParams;
+    constructor(apiConfig?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected encodeQueryParam(key: string, value: any): string;
+    protected addQueryParam(query: QueryParamsType, key: string): string;
+    protected addArrayQueryParam(query: QueryParamsType, key: string): any;
+    protected toQueryString(rawQuery?: QueryParamsType): string;
+    protected addQueryParams(rawQuery?: QueryParamsType): string;
+    private contentFormatters;
+    protected mergeRequestParams(params1: RequestParams, params2?: RequestParams): RequestParams;
+    protected createAbortSignal: (cancelToken: CancelToken) => AbortSignal | undefined;
+    abortRequest: (cancelToken: CancelToken) => void;
+    request: <T = any, E = any>({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }: FullRequestParams) => Promise<HttpResponse<T, E>>;
+}
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    wallets: {
+        getWallets: (params?: RequestParams) => Promise<WalletStatus[]>;
+        putWallets: (data: WalletRestore, params?: RequestParams) => Promise<WalletRestoreResult>;
+        postWallets: (data: WalletCreation, params?: RequestParams) => Promise<WalletCreationResult>;
+        getWalletsWalletName: (walletName: string, params?: RequestParams) => Promise<WalletStatus>;
+        deleteWalletsWalletName: (walletName: string, query: {
+            password: string;
+        }, params?: RequestParams) => Promise<void>;
+        postWalletsWalletNameLock: (walletName: string, params?: RequestParams) => Promise<void>;
+        postWalletsWalletNameUnlock: (walletName: string, data: WalletUnlock, params?: RequestParams) => Promise<void>;
+        getWalletsWalletNameBalances: (walletName: string, params?: RequestParams) => Promise<Balances>;
+        postWalletsWalletNameRevealMnemonic: (walletName: string, data: RevealMnemonic, params?: RequestParams) => Promise<RevealMnemonicResult>;
+        postWalletsWalletNameTransfer: (walletName: string, data: Transfer, params?: RequestParams) => Promise<TransferResult>;
+        postWalletsWalletNameSweepActiveAddress: (walletName: string, data: Sweep, params?: RequestParams) => Promise<TransferResults>;
+        postWalletsWalletNameSweepAllAddresses: (walletName: string, data: Sweep, params?: RequestParams) => Promise<TransferResults>;
+        postWalletsWalletNameSign: (walletName: string, data: Sign, params?: RequestParams) => Promise<SignResult>;
+        getWalletsWalletNameAddresses: (walletName: string, params?: RequestParams) => Promise<Addresses>;
+        getWalletsWalletNameAddressesAddress: (walletName: string, address: string, params?: RequestParams) => Promise<AddressInfo>;
+        getWalletsWalletNameMinerAddresses: (walletName: string, params?: RequestParams) => Promise<MinerAddressesInfo[]>;
+        postWalletsWalletNameDeriveNextAddress: (walletName: string, query?: {
+            group?: number;
+        }, params?: RequestParams) => Promise<AddressInfo>;
+        postWalletsWalletNameDeriveNextMinerAddresses: (walletName: string, params?: RequestParams) => Promise<AddressInfo[]>;
+        postWalletsWalletNameChangeActiveAddress: (walletName: string, data: ChangeActiveAddress, params?: RequestParams) => Promise<void>;
+    };
+    infos: {
+        getInfosNode: (params?: RequestParams) => Promise<NodeInfo>;
+        getInfosVersion: (params?: RequestParams) => Promise<NodeVersion>;
+        getInfosChainParams: (params?: RequestParams) => Promise<ChainParams>;
+        getInfosSelfClique: (params?: RequestParams) => Promise<SelfClique>;
+        getInfosInterCliquePeerInfo: (params?: RequestParams) => Promise<InterCliquePeerInfo[]>;
+        getInfosDiscoveredNeighbors: (params?: RequestParams) => Promise<BrokerInfo[]>;
+        getInfosMisbehaviors: (params?: RequestParams) => Promise<PeerMisbehavior[]>;
+        postInfosMisbehaviors: (data: MisbehaviorAction, params?: RequestParams) => Promise<void>;
+        getInfosUnreachable: (params?: RequestParams) => Promise<string[]>;
+        postInfosDiscovery: (data: DiscoveryAction, params?: RequestParams) => Promise<void>;
+        getInfosHistoryHashrate: (query: {
+            fromTs: number;
+            toTs?: number;
+        }, params?: RequestParams) => Promise<HashRateResponse>;
+        getInfosCurrentHashrate: (query?: {
+            timespan?: number;
+        }, params?: RequestParams) => Promise<HashRateResponse>;
+        getInfosCurrentDifficulty: (params?: RequestParams) => Promise<CurrentDifficulty>;
+    };
+    blockflow: {
+        getBlockflowBlocks: (query: {
+            fromTs: number;
+            toTs?: number;
+        }, params?: RequestParams) => Promise<BlocksPerTimeStampRange>;
+        getBlockflowBlocksWithEvents: (query: {
+            fromTs: number;
+            toTs?: number;
+        }, params?: RequestParams) => Promise<BlocksAndEventsPerTimeStampRange>;
+        getBlockflowRichBlocks: (query: {
+            fromTs: number;
+            toTs?: number;
+        }, params?: RequestParams) => Promise<RichBlocksAndEventsPerTimeStampRange>;
+        getBlockflowBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<BlockEntry>;
+        getBlockflowMainChainBlockByGhostUncleGhostUncleHash: (ghostUncleHash: string, params?: RequestParams) => Promise<BlockEntry>;
+        getBlockflowBlocksWithEventsBlockHash: (blockHash: string, params?: RequestParams) => Promise<BlockAndEvents>;
+        getBlockflowRichBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<RichBlockAndEvents>;
+        getBlockflowIsBlockInMainChain: (query: {
+            blockHash: string;
+        }, params?: RequestParams) => Promise<boolean>;
+        getBlockflowHashes: (query: {
+            fromGroup: number;
+            toGroup: number;
+            height: number;
+        }, params?: RequestParams) => Promise<HashesAtHeight>;
+        getBlockflowChainInfo: (query: {
+            fromGroup: number;
+            toGroup: number;
+        }, params?: RequestParams) => Promise<ChainInfo>;
+        getBlockflowHeadersBlockHash: (blockHash: string, params?: RequestParams) => Promise<BlockHeaderEntry>;
+        getBlockflowRawBlocksBlockHash: (blockHash: string, params?: RequestParams) => Promise<RawBlock>;
+    };
+    addresses: {
+        getAddressesAddressBalance: (address: string, query?: {
+            mempool?: boolean;
+        }, params?: RequestParams) => Promise<Balance>;
+        getAddressesAddressUtxos: (address: string, query?: {
+            "error-if-exceed-max-utxos"?: boolean;
+        }, params?: RequestParams) => Promise<UTXOs>;
+        getAddressesAddressGroup: (address: string, params?: RequestParams) => Promise<Group>;
+    };
+    transactions: {
+        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult | BuildGrouplessTransferTxResult>;
+        postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult[]>;
+        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
+        postTransactionsSweepAddressBuild: (data: BuildSweepAddressTransactions, params?: RequestParams) => Promise<BuildSweepAddressTransactionsResult>;
+        postTransactionsSubmit: (data: SubmitTransaction, params?: RequestParams) => Promise<SubmitTxResult>;
+        postTransactionsDecodeUnsignedTx: (data: DecodeUnsignedTx, params?: RequestParams) => Promise<DecodeUnsignedTxResult>;
+        getTransactionsDetailsTxid: (txId: string, query?: {
+            fromGroup?: number;
+            toGroup?: number;
+        }, params?: RequestParams) => Promise<Transaction>;
+        getTransactionsRichDetailsTxid: (txId: string, query?: {
+            fromGroup?: number;
+            toGroup?: number;
+        }, params?: RequestParams) => Promise<RichTransaction>;
+        getTransactionsRawTxid: (txId: string, query?: {
+            fromGroup?: number;
+            toGroup?: number;
+        }, params?: RequestParams) => Promise<RawTransaction>;
+        getTransactionsStatus: (query: {
+            txId: string;
+            fromGroup?: number;
+            toGroup?: number;
+        }, params?: RequestParams) => Promise<Confirmed | Conflicted | MemPooled | TxNotFound>;
+        getTransactionsTxIdFromOutputref: (query: {
+            hint: number;
+            key: string;
+        }, params?: RequestParams) => Promise<string>;
+        postTransactionsBuildChained: (data: BuildChainedTx[], params?: RequestParams) => Promise<BuildChainedTxResult[]>;
+    };
+    mempool: {
+        getMempoolTransactions: (params?: RequestParams) => Promise<MempoolTransactions[]>;
+        deleteMempoolTransactions: (params?: RequestParams) => Promise<void>;
+        putMempoolTransactionsRebroadcast: (query: {
+            txId: string;
+        }, params?: RequestParams) => Promise<void>;
+        putMempoolTransactionsValidate: (params?: RequestParams) => Promise<void>;
+    };
+    contracts: {
+        postContractsCompileScript: (data: Script, params?: RequestParams) => Promise<CompileScriptResult>;
+        postContractsUnsignedTxExecuteScript: (data: BuildExecuteScriptTx, params?: RequestParams) => Promise<BuildSimpleExecuteScriptTxResult | BuildGrouplessExecuteScriptTxResult>;
+        postContractsCompileContract: (data: Contract, params?: RequestParams) => Promise<CompileContractResult>;
+        postContractsCompileProject: (data: Project, params?: RequestParams) => Promise<CompileProjectResult>;
+        postContractsUnsignedTxDeployContract: (data: BuildDeployContractTx, params?: RequestParams) => Promise<BuildSimpleDeployContractTxResult | BuildGrouplessDeployContractTxResult>;
+        getContractsAddressState: (address: string, params?: RequestParams) => Promise<ContractState>;
+        getContractsCodehashCode: (codeHash: string, params?: RequestParams) => Promise<string>;
+        postContractsTestContract: (data: TestContract, params?: RequestParams) => Promise<TestContractResult>;
+        postContractsCallContract: (data: CallContract, params?: RequestParams) => Promise<CallContractFailed | CallContractSucceeded>;
+        postContractsMulticallContract: (data: MultipleCallContract, params?: RequestParams) => Promise<MultipleCallContractResult>;
+        getContractsAddressParent: (address: string, params?: RequestParams) => Promise<string>;
+        getContractsAddressSubContracts: (address: string, query: {
+            start: number;
+            limit?: number;
+        }, params?: RequestParams) => Promise<SubContracts>;
+        getContractsAddressSubContractsCurrentCount: (address: string, params?: RequestParams) => Promise<number>;
+        postContractsCallTxScript: (data: CallTxScript, params?: RequestParams) => Promise<CallTxScriptResult>;
+    };
+    multisig: {
+        postMultisigAddress: (data: BuildMultisigAddress, params?: RequestParams) => Promise<BuildMultisigAddressResult>;
+        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildSimpleTransferTxResult | BuildGrouplessTransferTxResult>;
+        postMultisigSweep: (data: BuildSweepMultisig, params?: RequestParams) => Promise<BuildSweepAddressTransactionsResult>;
+        postMultisigSubmit: (data: SubmitMultisig, params?: RequestParams) => Promise<SubmitTxResult>;
+    };
+    miners: {
+        postMinersCpuMining: (query: {
+            action: string;
+        }, params?: RequestParams) => Promise<boolean>;
+        postMinersCpuMiningMineOneBlock: (query: {
+            fromGroup: number;
+            toGroup: number;
+        }, params?: RequestParams) => Promise<boolean>;
+        getMinersAddresses: (params?: RequestParams) => Promise<MinerAddresses>;
+        putMinersAddresses: (data: MinerAddresses, params?: RequestParams) => Promise<void>;
+    };
+    events: {
+        getEventsContractContractaddress: (contractAddress: string, query: {
+            start: number;
+            limit?: number;
+            group?: number;
+        }, params?: RequestParams) => Promise<ContractEvents>;
+        getEventsContractContractaddressCurrentCount: (contractAddress: string, params?: RequestParams) => Promise<number>;
+        getEventsTxIdTxid: (txId: string, query?: {
+            group?: number;
+        }, params?: RequestParams) => Promise<ContractEventsByTxId>;
+        getEventsBlockHashBlockhash: (blockHash: string, query?: {
+            group?: number;
+        }, params?: RequestParams) => Promise<ContractEventsByBlockHash>;
+    };
+    utils: {
+        postUtilsVerifySignature: (data: VerifySignature, params?: RequestParams) => Promise<boolean>;
+        postUtilsTargetToHashrate: (data: TargetToHashrate, params?: RequestParams) => Promise<Result>;
+        putUtilsCheckHashIndexing: (params?: RequestParams) => Promise<void>;
+    };
+}
+export {};