import type { ChainContract } from "viem";
import type { AliasMap, Repository, Shared } from "../shared/types.js";
import type * as enums from "./enums.js";
export declare namespace EVM {
    type Address = `0x${string}`;
    type AbiMap = {
        [contractName: string]: readonly object[];
    };
    type Chain = Shared.Chain & {
        contracts: NonNullable<Shared.Chain["contracts"]> & {
            multicall3: ChainContract;
        };
        isZK: boolean;
        rpc: Shared.Chain["rpc"] & {
            alchemy?: (apiKey: string) => string;
            infura?: (apiKey: string) => string;
            routemesh?: (apiKey: string) => string;
        };
    };
    type Contract = Shared.Contract<Address, Protocol, Version>;
    type ContractCatalog = {
        [protocol in Protocol]: {
            [chainId: number]: {
                [address: Address]: Contract;
            };
        };
    };
    type AliasCatalog = {
        [protocol in Protocol]: {
            [chainId: number]: {
                [alias: string]: Contract;
            };
        };
    };
    type Protocol = `${enums.Protocol}` | enums.Protocol;
    type CompilerSettings = {
        evmVersion: string;
        optimizer: boolean;
        optimizerRuns: number;
        salt?: string;
        solcVersion: `v${number}.${number}.${number}`;
        viaIR: boolean;
        zkVersion?: `v${number}.${number}.${number}`;
    };
    namespace Deployment {
        type Standard = {
            chainId: number;
            contracts: Contract[];
            compilerSettings?: CompilerSettings;
        };
        type LockupV1 = Standard & {
            core: Contract[];
            periphery: Contract[];
        };
    }
    type Deployment = Deployment.Standard | Deployment.LockupV1;
    namespace Manifest {
        type LockupV1 = {
            core: Standard;
            periphery: Standard;
        };
        type Standard = Shared.Manifest;
    }
    type Manifest = Manifest.LockupV1 | Manifest.Standard;
    type AirdropsReleaseFeatures = {
        payable: boolean;
        claimTo: boolean;
        comptroller: boolean;
        sponsor: boolean;
    };
    type FlowReleaseFeatures = {
        payable: boolean;
        comptroller: boolean;
        minFee: boolean;
        simpleTransfer: boolean;
    };
    type LockupReleaseFeatures = {
        payable: boolean;
        comptroller: boolean;
        minFee: boolean;
        prbProxy: boolean;
        publicWithdraw: boolean;
        batch: boolean;
        legacyAbi: boolean;
        shape: boolean;
    };
    type EmptyReleaseFeatures = Record<never, never>;
    type EvmReleaseFeatures = AirdropsReleaseFeatures | FlowReleaseFeatures | LockupReleaseFeatures | EmptyReleaseFeatures;
    namespace Release {
        type Common<TAbiMap extends AbiMap = AbiMap, TFeatures extends EvmReleaseFeatures = EvmReleaseFeatures> = {
            abi: TAbiMap;
            aliases?: AliasMap;
            contractNames: string[];
            features: TFeatures;
            isLatest: boolean;
            kind: "standard" | "lockupV1";
            protocol: Protocol;
            repository?: Repository;
            version: Version;
        };
        export type LockupV1<TAbiMap extends AbiMap = AbiMap, TFeatures extends EvmReleaseFeatures = EvmReleaseFeatures> = Common<TAbiMap, TFeatures> & {
            deployments: Deployment.LockupV1[];
            kind: "lockupV1";
            manifest: Manifest.LockupV1;
        };
        export type Standard<TAbiMap extends AbiMap = AbiMap, TFeatures extends EvmReleaseFeatures = EvmReleaseFeatures> = Common<TAbiMap, TFeatures> & {
            deployments: Deployment.Standard[];
            kind: "standard";
            manifest: Manifest.Standard;
        };
        export {};
    }
    type Release = Release.Standard | Release.LockupV1;
    namespace Version {
        type Airdrops = `${enums.Version.Airdrops}` | enums.Version.Airdrops;
        type Bob = `${enums.Version.Bob}` | enums.Version.Bob;
        type Flow = `${enums.Version.Flow}` | enums.Version.Flow;
        type Legacy = `${enums.Version.Legacy}` | enums.Version.Legacy;
        type Lockup = `${enums.Version.Lockup}` | enums.Version.Lockup;
    }
    type Version = Version.Airdrops | Version.Bob | Version.Flow | Version.Legacy | Version.Lockup;
}
//# sourceMappingURL=types.d.ts.map