import { z } from 'zod';
declare const zodCompilerOutputSource: z.ZodObject<{
    keccak256: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    urls: z.ZodArray<z.ZodString, "many">;
    license: z.ZodString;
}, "strip", z.ZodTypeAny, {
    keccak256: `0x${string}`;
    urls: string[];
    license: string;
}, {
    keccak256: string;
    urls: string[];
    license: string;
}>;
declare const zodForgeArtifact: z.ZodObject<{
    abi: z.ZodReadonly<z.ZodArray<z.ZodUnion<[z.ZodObject<{
        type: z.ZodLiteral<"error">;
        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
        name: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        inputs: readonly import("abitype").AbiParameter[];
        type: "error";
        name: string;
    }, {
        inputs: readonly import("abitype").AbiParameter[];
        type: "error";
        name: string;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"event">;
        anonymous: z.ZodOptional<z.ZodBoolean>;
        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiEventParameter, z.ZodTypeDef, import("abitype").AbiEventParameter>, "many">>;
        name: z.ZodString;
    }, "strip", z.ZodTypeAny, {
        inputs: readonly import("abitype").AbiEventParameter[];
        type: "event";
        name: string;
        anonymous?: boolean | undefined;
    }, {
        inputs: readonly import("abitype").AbiEventParameter[];
        type: "event";
        name: string;
        anonymous?: boolean | undefined;
    }>, z.ZodEffects<z.ZodIntersection<z.ZodObject<{
        constant: z.ZodOptional<z.ZodBoolean>;
        gas: z.ZodOptional<z.ZodNumber>;
        payable: z.ZodOptional<z.ZodBoolean>;
    }, "strip", z.ZodTypeAny, {
        payable?: boolean | undefined;
        constant?: boolean | undefined;
        gas?: number | undefined;
    }, {
        payable?: boolean | undefined;
        constant?: boolean | undefined;
        gas?: number | undefined;
    }>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
        type: z.ZodLiteral<"function">;
        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
        name: z.ZodString;
        outputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
        stateMutability: z.ZodUnion<[z.ZodLiteral<"pure">, z.ZodLiteral<"view">, z.ZodLiteral<"nonpayable">, z.ZodLiteral<"payable">]>;
    }, "strip", z.ZodTypeAny, {
        inputs: readonly import("abitype").AbiParameter[];
        outputs: readonly import("abitype").AbiParameter[];
        type: "function";
        name: string;
        stateMutability: "pure" | "view" | "nonpayable" | "payable";
    }, {
        inputs: readonly import("abitype").AbiParameter[];
        outputs: readonly import("abitype").AbiParameter[];
        type: "function";
        name: string;
        stateMutability: "pure" | "view" | "nonpayable" | "payable";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"constructor">;
        inputs: z.ZodReadonly<z.ZodArray<z.ZodType<import("abitype").AbiParameter, z.ZodTypeDef, import("abitype").AbiParameter>, "many">>;
        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
    }, "strip", z.ZodTypeAny, {
        inputs: readonly import("abitype").AbiParameter[];
        type: "constructor";
        stateMutability: "nonpayable" | "payable";
    }, {
        inputs: readonly import("abitype").AbiParameter[];
        type: "constructor";
        stateMutability: "nonpayable" | "payable";
    }>, z.ZodObject<{
        type: z.ZodLiteral<"fallback">;
        inputs: z.ZodOptional<z.ZodTuple<[], null>>;
        stateMutability: z.ZodUnion<[z.ZodLiteral<"payable">, z.ZodLiteral<"nonpayable">]>;
    }, "strip", z.ZodTypeAny, {
        type: "fallback";
        stateMutability: "nonpayable" | "payable";
        inputs?: [] | undefined;
    }, {
        type: "fallback";
        stateMutability: "nonpayable" | "payable";
        inputs?: [] | undefined;
    }>, z.ZodObject<{
        type: z.ZodLiteral<"receive">;
        stateMutability: z.ZodLiteral<"payable">;
    }, "strip", z.ZodTypeAny, {
        type: "receive";
        stateMutability: "payable";
    }, {
        type: "receive";
        stateMutability: "payable";
    }>]>>, {
        payable?: boolean | undefined;
        constant?: boolean | undefined;
        gas?: number | undefined;
    } & ({
        inputs: readonly import("abitype").AbiParameter[];
        outputs: readonly import("abitype").AbiParameter[];
        type: "function";
        name: string;
        stateMutability: "pure" | "view" | "nonpayable" | "payable";
    } | {
        inputs: readonly import("abitype").AbiParameter[];
        type: "constructor";
        stateMutability: "nonpayable" | "payable";
    } | {
        type: "fallback";
        stateMutability: "nonpayable" | "payable";
        inputs?: [] | undefined;
    } | {
        type: "receive";
        stateMutability: "payable";
    }), unknown>]>, "many">>;
    bytecode: z.ZodObject<{
        object: z.ZodEffects<z.ZodString, `0x${string}`, string>;
    }, "strip", z.ZodTypeAny, {
        object: `0x${string}`;
    }, {
        object: string;
    }>;
    metadata: z.ZodObject<{
        compiler: z.ZodObject<{
            version: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            version: string;
        }, {
            version: string;
        }>;
        language: z.ZodEnum<["Solidity", "Vyper"]>;
        sources: z.ZodRecord<z.ZodString, z.ZodObject<{
            keccak256: z.ZodEffects<z.ZodString, `0x${string}`, string>;
            urls: z.ZodArray<z.ZodString, "many">;
            license: z.ZodString;
        }, "strip", z.ZodTypeAny, {
            keccak256: `0x${string}`;
            urls: string[];
            license: string;
        }, {
            keccak256: string;
            urls: string[];
            license: string;
        }>>;
        version: z.ZodNumber;
        settings: z.ZodObject<{
            remappings: z.ZodArray<z.ZodString, "many">;
            optimizer: z.ZodObject<{
                enabled: z.ZodBoolean;
                runs: z.ZodNumber;
                details: z.ZodOptional<z.ZodObject<{
                    peephole: z.ZodBoolean;
                }, "strip", z.ZodTypeAny, {
                    peephole: boolean;
                }, {
                    peephole: boolean;
                }>>;
            }, "strip", z.ZodTypeAny, {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            }, {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            }>;
            metadata: z.ZodObject<{
                bytecodeHash: z.ZodString;
            }, "strip", z.ZodTypeAny, {
                bytecodeHash: string;
            }, {
                bytecodeHash: string;
            }>;
            compilationTarget: z.ZodRecord<z.ZodString, z.ZodString>;
            evmVersion: z.ZodString;
            libraries: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `0x${string}`, string>>>;
        }, "strip", z.ZodTypeAny, {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, `0x${string}`>>;
        }, {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, string>>;
        }>;
    }, "strip", z.ZodTypeAny, {
        version: number;
        compiler: {
            version: string;
        };
        language: "Solidity" | "Vyper";
        sources: Record<string, {
            keccak256: `0x${string}`;
            urls: string[];
            license: string;
        }>;
        settings: {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, `0x${string}`>>;
        };
    }, {
        version: number;
        compiler: {
            version: string;
        };
        language: "Solidity" | "Vyper";
        sources: Record<string, {
            keccak256: string;
            urls: string[];
            license: string;
        }>;
        settings: {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, string>>;
        };
    }>;
}, "strip", z.ZodTypeAny, {
    abi: readonly ({
        inputs: readonly import("abitype").AbiParameter[];
        type: "error";
        name: string;
    } | {
        inputs: readonly import("abitype").AbiEventParameter[];
        type: "event";
        name: string;
        anonymous?: boolean | undefined;
    } | ({
        payable?: boolean | undefined;
        constant?: boolean | undefined;
        gas?: number | undefined;
    } & ({
        inputs: readonly import("abitype").AbiParameter[];
        outputs: readonly import("abitype").AbiParameter[];
        type: "function";
        name: string;
        stateMutability: "pure" | "view" | "nonpayable" | "payable";
    } | {
        inputs: readonly import("abitype").AbiParameter[];
        type: "constructor";
        stateMutability: "nonpayable" | "payable";
    } | {
        type: "fallback";
        stateMutability: "nonpayable" | "payable";
        inputs?: [] | undefined;
    } | {
        type: "receive";
        stateMutability: "payable";
    })))[];
    bytecode: {
        object: `0x${string}`;
    };
    metadata: {
        version: number;
        compiler: {
            version: string;
        };
        language: "Solidity" | "Vyper";
        sources: Record<string, {
            keccak256: `0x${string}`;
            urls: string[];
            license: string;
        }>;
        settings: {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, `0x${string}`>>;
        };
    };
}, {
    abi: readonly unknown[];
    bytecode: {
        object: string;
    };
    metadata: {
        version: number;
        compiler: {
            version: string;
        };
        language: "Solidity" | "Vyper";
        sources: Record<string, {
            keccak256: string;
            urls: string[];
            license: string;
        }>;
        settings: {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, string>>;
        };
    };
}>;
export type CompilerOutputSource = z.infer<typeof zodCompilerOutputSource>;
export type ForgeArtifact = z.infer<typeof zodForgeArtifact>;
export declare const readForgeArtifact: (artifactPath: string) => Promise<{
    abi: readonly ({
        inputs: readonly import("abitype").AbiParameter[];
        type: "error";
        name: string;
    } | {
        inputs: readonly import("abitype").AbiEventParameter[];
        type: "event";
        name: string;
        anonymous?: boolean | undefined;
    } | ({
        payable?: boolean | undefined;
        constant?: boolean | undefined;
        gas?: number | undefined;
    } & ({
        inputs: readonly import("abitype").AbiParameter[];
        outputs: readonly import("abitype").AbiParameter[];
        type: "function";
        name: string;
        stateMutability: "pure" | "view" | "nonpayable" | "payable";
    } | {
        inputs: readonly import("abitype").AbiParameter[];
        type: "constructor";
        stateMutability: "nonpayable" | "payable";
    } | {
        type: "fallback";
        stateMutability: "nonpayable" | "payable";
        inputs?: [] | undefined;
    } | {
        type: "receive";
        stateMutability: "payable";
    })))[];
    bytecode: {
        object: `0x${string}`;
    };
    metadata: {
        version: number;
        compiler: {
            version: string;
        };
        language: "Solidity" | "Vyper";
        sources: Record<string, {
            keccak256: `0x${string}`;
            urls: string[];
            license: string;
        }>;
        settings: {
            metadata: {
                bytecodeHash: string;
            };
            remappings: string[];
            optimizer: {
                enabled: boolean;
                runs: number;
                details?: {
                    peephole: boolean;
                } | undefined;
            };
            compilationTarget: Record<string, string>;
            evmVersion: string;
            libraries: Record<string, Record<string, `0x${string}`>>;
        };
    };
}>;
export {};
