import { Web3Client } from '../../clients/Web3Client';
import { ContractBase } from '../ContractBase';
import { IAccount } from '../../models/TAccount';
import { TEth } from '../../models/TEth';
import { ParametersFromSecond } from '../../utils/types';
import { Constructor } from '../../utils/types';
import { IBeacon, IBeaconProxy, IProxy, IProxyAdmin } from './proxy/ProxyDeployment';
import { DeploymentsStorage, IDeployment } from './storage/DeploymentsStorage';
import { TAddress } from '../../models/TAddress';
type TDeploymentOptions = {
    id?: string;
    /** Will deploy the contract */
    force?: boolean;
    /** Will check if local bytecode has changed and will deploy */
    latest?: boolean;
    verification?: boolean | 'silent';
    proxyFor?: TAddress;
    deployment?: {
        tx?: TEth.Hex;
        upgradeProxy?: boolean;
        owner?: TEth.IAccount;
    };
};
export declare class Deployments {
    client: Web3Client;
    deployer: IAccount;
    opts: {
        owner?: IAccount;
        Proxy?: Constructor<ContractBase>;
        ProxyAdmin?: Constructor<IProxyAdmin>;
        directory?: string;
        name?: string;
        fork?: string;
        Beacon?: {
            Beacon: Constructor<IBeacon>;
            BeaconProxy: Constructor<IBeaconProxy>;
        };
        verification?: boolean;
        checkBytecode?: boolean;
        whenBytecodeChanged?: 'redeploy' | 'ignore' | 'throw';
        whenUpgradeRequired?: 'ignore';
    };
    store: DeploymentsStorage;
    private _logger;
    private _hh;
    private _proxyDeployment;
    private _config;
    constructor(client: Web3Client, deployer: IAccount, opts?: {
        owner?: IAccount;
        Proxy?: Constructor<ContractBase>;
        ProxyAdmin?: Constructor<IProxyAdmin>;
        directory?: string;
        name?: string;
        fork?: string;
        Beacon?: {
            Beacon: Constructor<IBeacon>;
            BeaconProxy: Constructor<IBeaconProxy>;
        };
        verification?: boolean;
        checkBytecode?: boolean;
        whenBytecodeChanged?: 'redeploy' | 'ignore' | 'throw';
        whenUpgradeRequired?: 'ignore';
    });
    has<T extends ContractBase>(Ctor: Constructor<T>, opts?: {
        id?: string;
        params?: ConstructorParameters<Constructor<T>>;
    }): Promise<boolean>;
    get<T extends ContractBase>(Ctor: Constructor<T>, opts?: {
        id?: string;
        address?: TAddress;
        version?: string;
    }): Promise<T>;
    getIfExists<T extends ContractBase>(Ctor: Constructor<T>, opts?: {
        id?: string;
        address?: TAddress;
    }): Promise<T>;
    private getOrNull;
    /**
     * Get the deployment for Ctor, but returns the CtorWrapped instance. Useful for proxies, etc.
     * e.g. deployments.getAs(SomeProxy, SomeImplementation);
     */
    getAs<TDeployed extends ContractBase, TWrapped extends ContractBase>(Ctor: Constructor<TDeployed>, CtorWrapped: Constructor<TWrapped>, opts?: {
        id?: string;
    }): Promise<TWrapped>;
    verify(params: {
        id: string;
        address?: TAddress;
        Ctor: Constructor<ContractBase>;
        constructorParams?: any[];
    }): Promise<void>;
    ensureContract<T extends TContract>(Ctor: Constructor<T>, opts?: TConstructorArgs<T> & {
        id?: string;
        force?: boolean;
    }): Promise<T>;
    ensure<T extends TContract>(Ctor: Constructor<T>, opts?: TConstructorArgs<T> & TDeploymentOptions): Promise<{
        contract: T;
        receipt?: TEth.TxReceipt;
        deployment: IDeployment;
    }>;
    ensureWithProxy<T extends (TContract & {
        initialize?: TInit;
    }), TInit extends TInitializer>(CtorImpl: Constructor<T>, opts?: TConstructorArgs<T> & TDeploymentOptions & {
        initialize?: ParametersFromSecond<T['initialize']>;
    }): Promise<{
        contract: T;
        contractReceipt?: TEth.TxReceipt;
        contractProxy: IProxy;
        contractProxyAdmin: IProxyAdmin;
        contractImplementation: T;
        deployment: IDeployment;
    }>;
    /**
     * Deploys the Beacon contract. Implementation is the target contract (can be a proxy or normal contract)
     * https://docs.openzeppelin.com/contracts/5.x/api/proxy#beacon
     **/
    ensureWithBeacon<T extends (TContract & {
        initialize?: TInit;
    }), TInit extends TInitializer>(CtorImpl: Constructor<T>, opts: TConstructorArgs<T> & TDeploymentOptions & {
        id: string;
        initialize?: ParametersFromSecond<T['initialize']>;
    }): Promise<{
        contract: T;
        contractReceipt?: TEth.TxReceipt;
        contractDeployment: IDeployment;
        contractBeacon: IBeacon;
        contractBeaconDeployment: IDeployment;
        contractBeaconProxy: IBeaconProxy;
        contractBeaconProxyDeployment: IDeployment;
    }>;
    private isSameBytecode;
    private ensureVerification;
    fixBytecodeHashesByReread(): Promise<void>;
    private getBytecodeHash;
    /**
     * A simple method to configure the contracts state
     */
    configure<T extends TContract, TValue>(Ctor: Constructor<T> | T, opts: {
        id?: string;
        value?: TValue;
        current?: TValue | Promise<TValue> | ((x: T) => Promise<TValue>);
        shouldUpdate?: boolean | (() => boolean | Promise<boolean>);
        updater: (x: T, value: TValue) => Promise<any>;
        title?: string;
    }): Promise<void>;
}
type TInitializer = (...args: any[]) => any;
type TContract = ContractBase & {
    $constructor?: (...args: any[]) => any;
};
type TConstructorArgs<T extends TContract> = T['$constructor'] extends Function ? {
    arguments: ParametersFromSecond<T['$constructor']>;
} : {
    arguments?: any[];
};
export {};