import "hardhat/types/config";
import "hardhat/types/runtime";
import { GetBlockResponse } from "starknet";
import { Account } from "./account";
import { StarknetChainId } from "./constants";
import { AmarnaDocker } from "./external-server/docker-amarna";
import { Transaction, TransactionReceipt, TransactionTrace } from "./starknet-types";
import { StarknetLegacyWrapper } from "./starknet-js-wrapper";
import { StarknetWrapper } from "./starknet-wrappers";
import { StarknetContract, StarknetContractFactory, StringMap } from "./types";
import * as DevnetTypes from "./types/devnet";
import * as StarknetTypes from "./types/starknet";
declare module "hardhat/types/config" {
    interface ProjectPathsUserConfig {
        starknetArtifacts?: string;
        starknetSources?: string;
        cairoPaths?: string[];
    }
    interface ProjectPathsConfig {
        starknetArtifacts: string;
        starknetSources?: string;
        cairoPaths?: string[];
    }
    interface HardhatConfig {
        starknet: StarknetTypes.StarknetConfig;
    }
    interface HardhatUserConfig {
        starknet?: StarknetTypes.StarknetConfig;
    }
    interface NetworksConfig {
        alphaGoerli: HttpNetworkConfig;
        alphaGoerli2: HttpNetworkConfig;
        alphaMainnet: HttpNetworkConfig;
        integratedDevnet: HardhatNetworkConfig;
    }
    interface NetworksUserConfig {
        integratedDevnet?: HardhatNetworkUserConfig;
    }
    interface HttpNetworkConfig {
        verificationUrl?: string;
        verifiedUrl?: string;
        starknetChainId?: StarknetChainId;
        vmLang?: VmLang;
    }
    interface HardhatNetworkConfig {
        url?: string;
        venv?: string;
        dockerizedVersion?: string;
        starknetChainId?: StarknetChainId;
        args?: string[];
        stdout?: string;
        stderr?: string;
        vmLang?: VmLang;
    }
    interface HardhatNetworkUserConfig {
        url?: string;
        venv?: string;
        dockerizedVersion?: string;
        args?: string[];
        stdout?: string;
        stderr?: string;
        vmLang?: VmLang;
    }
    type VmLang = "python" | "rust" | "";
}
type StarknetContractType = StarknetContract;
type StarknetContractFactoryType = StarknetContractFactory;
type StringMapType = StringMap;
type AccountType = Account;
type TransactionReceiptType = TransactionReceipt;
type TransactionTraceType = TransactionTrace;
type TransactionType = Transaction;
type BlockType = GetBlockResponse;
declare module "hardhat/types/runtime" {
    interface Devnet extends DevnetTypes.Devnet {
    }
    interface HardhatRuntimeEnvironment {
        starknetWrapper: StarknetWrapper;
        amarnaDocker: AmarnaDocker;
        starknet: StarknetTypes.Starknet;
        starknetJs: StarknetLegacyWrapper;
    }
    type StarknetContract = StarknetContractType;
    type StarknetContractFactory = StarknetContractFactoryType;
    type StringMap = StringMapType;
    type Account = AccountType;
    type Transaction = TransactionType;
    type TransactionReceipt = TransactionReceiptType;
    type TransactionTrace = TransactionTraceType;
    type Block = BlockType;
}
export {};