import type { SolidityBuildInfo } from "./solidity/solidity-artifacts.js";
import type { NonNeverKeys } from "./utils.js";
/**
 * A map of bare contract names and fully qualified contract names to their
 * artifacts that will be completed by Hardhat's build system using module
 * augmentation.
 */
export interface ArtifactMap {
}
/**
 * Returns the artifact type for the bare or fully qualified contract name.
 */
export type GetArtifactByName<ContractNameT extends string> = ContractNameT extends keyof ArtifactMap ? ArtifactMap[ContractNameT] : Artifact;
/**
 * A type that represents the contract names (bare and fully qualified) of all
 * the artifacts that have been built in a project. This enables the
 * autocomplete of the TS Language Server to list the actual contracts, without
 * leading to a compilation error for general strings, so it doesn't fail
 * before `hardhat build` is run.
 *
 * This is meant to be used in functions like this:
 * @example
 * ```
 * function doSomething<ContractNameT extends ArtifactContractNames>(
 *   contractName: ContractNameT,
 *   ...
 * ): DoSomethingReturnType<ContractNameT> {
 * }
 */
export type ArtifactContractNames = keyof ArtifactMap extends never ? string : NonNeverKeys<ArtifactMap>;
/**
 * A type that represents a string that should match an artifact contract name,
 * but it doesn't fail if the string is not a contract name. It's mostly used
 * to offer autocompletion.
 *
 * @see {@link ArtifactContractNames}
 */
export type StringWithArtifactContractNamesAutocompletion = ArtifactContractNames | (string & {});
/**
 * The ArtifactManager is responsible for reading and writing artifacts from
 * the Hardhat build system.
 */
export interface ArtifactManager {
    /**
     * Reads an artifact.
     *
     * @param contractNameOrFullyQualifiedName The name of the contract.
     *   It can be a contract bare contract name (e.g. "Token") if it's
     *   unique in your project, or a fully qualified contract name
     *   (e.g. "contract/token.sol:Token") otherwise. TypeScript's language server
     *   autocompletes the names of the contracts that have already been built. If
     *   your contract name isn't in the list, you can still use it, and/or run
     *   `hardhat build` to get it in the list.
     *
     * @throws Throws an error if a non-unique contract name is used,
     *   indicating which fully qualified names can be used instead.
     * @throws Throws an error if the artifact doesn't exist.
     */
    readArtifact<ContractNameT extends StringWithArtifactContractNamesAutocompletion>(contractNameOrFullyQualifiedName: ContractNameT): Promise<GetArtifactByName<ContractNameT>>;
    /**
     * Returns the absolute path to the given artifact.
     *
     * @param contractNameOrFullyQualifiedName The name or fully qualified name
     * of the contract.
     * @throws Throws an error if a non-unique contract name is used,
     *   indicating which fully qualified names can be used instead.
     * @throws Throws an error if the artifact doesn't exist.
     */
    getArtifactPath(contractNameOrFullyQualifiedName: string): Promise<string>;
    /**
     * Returns true if an artifact exists.
     *
     * This function doesn't throw if the name is not unique.
     *
     * @param contractNameOrFullyQualifiedName Contract or fully qualified name.
     * @throws Throws an error if a non-unique contract name is used,
     *   indicating which fully qualified names can be used instead.
     */
    artifactExists(contractNameOrFullyQualifiedName: string): Promise<boolean>;
    /**
     * Returns a set with the fully qualified names of all the artifacts.
     */
    getAllFullyQualifiedNames(): Promise<ReadonlySet<string>>;
    /**
     * Returns all artifact paths in the project.
     *
     * @returns A readonly set of absolute paths to all artifact files.
     */
    getAllArtifactPaths(): Promise<ReadonlySet<string>>;
    /**
     * Returns the BuildInfo id associated with the solc run that compiled a
     * contract.
     *
     * Note that it may return `undefined` if the artifact doesn't have a build
     * id, which can happen if the artifact wasn't compiled with Hardhat 3's build
     * system.
     *
     * If it does return an id, it's not guaranteed that the build info is
     * present.
     *
     * @param contractNameOrFullyQualifiedName Contract or fully qualified name, whose artifact must exist.
     * @throws Throws an error if a non-unique contract name is used,
     *   indicating which fully qualified names can be used instead.
     * @throws Throws an error if the artifact doesn't exist.
     * @returns The build info id, or undefined if the artifact doesn't have a
     *   build info id.
     */
    getBuildInfoId(contractNameOrFullyQualifiedName: string): Promise<string | undefined>;
    /**
     * Returns a set with the ids of all the existing build infos.
     *
     * Note that there's one build info per run of solc, so they can be shared
     * by different contracts.
     */
    getAllBuildInfoIds(): Promise<ReadonlySet<string>>;
    /**
     * Returns the absolute path to the given build info, or `undefined` if it
     * doesn't exist.
     *
     * @param buildInfoId The id of an existing build info.
     */
    getBuildInfoPath(buildInfoId: string): Promise<string | undefined>;
    /**
     * Returns the absolute path to the output of the given build info,
     * if present.
     *
     * Note that the build info may exist, but it's output may not. In that case,
     * this function returns `undefined`.
     *
     * @param buildInfoId The id of an existing build info.
     */
    getBuildInfoOutputPath(buildInfoId: string): Promise<string | undefined>;
    /**
     * An artifact manager may cache information about the artifacts present in
     * the project, for performance reasons. For example, it may read the entire
     * list of artifacts from the file system, and cache it in memory.
     *
     * This method clears the artifact manager's cache, if any.
     *
     * This method is not meant to be used by end users, but by the Hardhat team
     * and build-system-related plugins.
     */
    clearCache(): Promise<void>;
}
/**
 * TODO: This type could be improved to better represent the ABI.
 */
export type Abi = readonly any[];
/**
 * An Artifact represents the compilation output of a single contract.
 *
 * This file has just enough information to deploy the contract and interact
 * with an already deployed instance of it.
 */
export interface Artifact<AbiT extends Abi = Abi> {
    /**
     * The version identifier of this format.
     */
    readonly _format: "hh3-artifact-1";
    /**
     * The bare name of the contract (i.e. without the source name).
     */
    readonly contractName: string;
    /**
     * The name of the file where the contract is defined.
     *
     * When Hardhat generates artifacts, it uses the following logic to determine
     * the source name:
     *   - The relative path from the root of the project, if the contract is
     *     defined in a file in the project.
     *   - The npm module identifier (i.e. `<package>/<file>`) if the contract
     *     is defined in a file in a npm package.
     *   - This may or may not be the same as the source name used by `solc`.
     *     For that information, see `inputSourceName`.
     *
     * This source name is used to determine the path to the artifact, and to
     * generate its fully qualified name.
     */
    readonly sourceName: string;
    /**
     * The ABI of the contract.
     */
    readonly abi: AbiT;
    /**
     * The bytecode used to deploy the contract.
     */
    readonly bytecode: string;
    /**
     * The link references of the deployment bytecode.
     */
    readonly linkReferences: LinkReferences;
    /**
     * The deployed or runtime bytecode of the contract.
     */
    readonly deployedBytecode: string;
    /**
     * The link references of the deployed bytecode.
     */
    readonly deployedLinkReferences: LinkReferences;
    /**
     * The references to the immutable variables that get embedded in the deployed
     * bytecode.
     */
    readonly immutableReferences?: ImmutableReferences;
    /**
     * The id of the build info that was used to generate this artifact.
     *
     * This may not be present if the artifact wasn't generated by Hardhat's build
     * system.
     */
    readonly buildInfoId?: string;
    /**
     * The source name of the file in the build info's source map that has this
     * contract's code.
     *
     * This can be different from the source name of the artifact, and is always
     * present when compiling Solidity code with Hardhat 3.
     */
    readonly inputSourceName?: string;
}
/**
 * The link references of a contract, which need to be resolved before using it.
 */
export interface LinkReferences {
    [libraryInputSourceName: string]: {
        [libraryName: string]: Array<{
            length: number;
            start: number;
        }>;
    };
}
/**
 * The references to the immutable variables that get embedded in the deployed
 * bytecode.
 *
 * Each immutable variable is represented by an id, which in the case of solc
 * is the id of the AST node that represents the variable.
 */
export interface ImmutableReferences {
    [immutableId: string]: Array<{
        start: number;
        length: number;
    }>;
}
/**
 * A BuildInfo is a file containing all the information to reproduce a build.
 *
 * Note that currently, BuildInfos are only generated for Solidity contracts,
 * and this will change once we add support for Vyper, so if you are using this,
 * keep in mind that you will need to update your code to support or ignore
 * Vyper's artifacts.
 */
export type BuildInfo = SolidityBuildInfo;
//# sourceMappingURL=artifacts.d.ts.map