import type { ContractBase } from '../contracts/ContractBase';
import type { TAbiItem } from '../types/TAbi';
import type { TEth } from '../models/TEth';
import { EoAccount } from '../models/TAccount';
import { HardhatWeb3Client } from './HardhatWeb3Client';
import { Web3Client } from '../clients/Web3Client';
import { IGeneratorSources } from '../gen/Generator';
import { IContractWrapped } from '../contracts/ContractClassFactory';
import { IWeb3EndpointOptions } from '../clients/interfaces/IWeb3EndpointOptions';
import { TPlatform } from '../models/TPlatform';
import { ContractDeployment } from '../contracts/deploy/ContractDeployment';
import { TAddress } from '../models/TAddress';
import { Constructor } from '../utils/types';
import { BlockchainExplorer } from '../explorer/BlockchainExplorer';
type THardhatLib = typeof import('hardhat');
export declare class HardhatProvider {
    client(network?: 'hardhat' | 'localhost', opts?: IWeb3EndpointOptions): HardhatWeb3Client;
    forked(params?: {
        platform?: TPlatform;
        url?: string;
        block?: number | 'latest';
    }): Promise<HardhatWeb3Client>;
    explorer(network?: 'hardhat' | 'localhost'): Promise<BlockchainExplorer>;
    deployer(index?: number): EoAccount;
    getFactoryForClass<T extends ContractBase>(Ctor: Constructor<T>, options?: {
        deployer?: EoAccount;
        arguments?: any[];
        client?: Web3Client;
    }): Promise<{
        factory: ContractDeployment;
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        deployedBytecode: TEth.Hex;
    }>;
    deployClass<T extends ContractBase>(Ctor: Constructor<T>, options?: {
        deployer?: EoAccount;
        arguments?: any[];
        client?: Web3Client;
        tx?: TEth.Hex;
    }): Promise<{
        contract: T;
        receipt: TEth.TxReceipt;
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        deployedBytecode: TEth.Hex;
    }>;
    deploySol<TReturn extends ContractBase = IContractWrapped>(solContractPath: string, options?: {
        client?: Web3Client;
        arguments?: any[];
        deployer?: EoAccount;
        paths?: {
            root?: string;
            artifacts?: string;
        };
        contractName?: string;
        tmpDir?: string;
    }): Promise<{
        contract: TReturn;
        ContractCtor: Constructor<TReturn>;
        receipt: TEth.TxReceipt;
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        source: IGeneratorSources;
    }>;
    deployBytecode<TReturn extends ContractBase = IContractWrapped>(hex: TEth.Hex, options?: {
        client?: Web3Client;
        arguments?: any[];
        deployer?: EoAccount;
        paths?: {
            root?: string;
            artifacts?: string;
        };
        contractName?: string;
        abi?: TAbiItem[];
    }): Promise<{
        contract: TReturn;
        ContractCtor: Constructor<TReturn>;
        receipt: TEth.TxReceipt;
        abi: TAbiItem[];
        bytecode: TEth.Hex;
    }>;
    compileSolDirectory(dir: string, options?: {
        paths?: {
            root?: string;
            artifacts?: string;
        };
        contractName?: string;
        tsgen?: boolean;
        install?: string;
    }): Promise<{
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        output: string;
        artifact: string;
        source: IGeneratorSources;
        ContractCtor: Constructor<IContractWrapped>;
        linkReferences?: Record<string, Record<string, any>>;
    }[]>;
    compileSol<T extends ContractBase = IContractWrapped>(solContractPath: string, options?: {
        paths?: {
            root?: string;
            artifacts?: string;
        };
        contractName?: string;
        tsgen?: boolean;
        install?: string;
    }): Promise<{
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        output: string;
        artifact: string;
        source: IGeneratorSources;
        ContractCtor: Constructor<T>;
        linkReferences?: Record<string, Record<string, any>>;
    }>;
    deployCode<TReturn extends ContractBase = IContractWrapped>(solidityCode: string, options?: Parameters<HardhatProvider['deploySol']>[1]): Promise<{
        contract: TReturn;
        ContractCtor: Constructor<TReturn>;
        receipt: TEth.TxReceipt;
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        source: IGeneratorSources;
    }>;
    linkReferences(bytecode: TEth.Hex, linkReferences: Record<string, Record<string, any>>, addresses: Record<string, TAddress>): Promise<TEth.Hex>;
    compileCode(solidityCode: string, options?: Parameters<HardhatProvider['deploySol']>[1]): Promise<{
        abi: TAbiItem[];
        bytecode: TEth.Hex;
        output: string;
        artifact: string;
        source: IGeneratorSources;
        ContractCtor: Constructor<IContractWrapped>;
        linkReferences?: Record<string, Record<string, any>>;
    }>;
    private createTmpFile;
    private getFactory;
    getHardhat(): Promise<THardhatLib>;
    private getHardhatProvider;
    private getArtifactJsonPath;
    private getPaths;
    private getSolFileContent;
    getContractFromSolPath<T extends ContractBase = IContractWrapped>(solContractPath: string, options?: {
        contractName?: string;
        paths: {
            sources?: string;
            root?: string;
            artifacts?: string;
        };
    }): Promise<{
        abi: TEth.Abi.Item[];
        bytecode: `0x${string}`;
        output: string;
        artifact: string;
        source: {
            contractName: string;
            files: {
                [key: string]: {
                    content: string;
                };
            };
        };
        linkReferences: Record<string, Record<string, any>>;
        ContractCtor: Constructor<T>;
    }>;
}
export {};