import { Signer, Provider, InterfaceAbi, BytesLike, TransactionReceipt, BigNumberish, ethers } from 'ethers';

declare const FACTORY_ADDRESS: Record<number, string>;
declare const RPC_URLs: Record<number, string>;
declare const FactoryABI: readonly ["event ImplementationVersionAdded(address indexed owner, bytes32 indexed contractType, uint32 indexed version, address implementation)", "event ContractDeployed(address indexed implementationOwner, bytes32 indexed contractType, address indexed proxy, address deployer)", "function setImplementation(bytes32 contractType, address impl)", "function setImplementationWithPolicy(bytes32 contractType, address impl, bool cloneable, bool initRequired, bytes4 initSelector)", "function getLatestImplementation(address owner, bytes32 contractType) view returns (address)", "function getImplementationByVersion(address owner, bytes32 contractType, uint32 version) view returns (address impl, uint256 timestamp)", "function getImplementationPolicy(address owner, bytes32 contractType, uint32 version) view returns ((bool isSet, bool cloneable, bool initRequired, bytes4 initSelector))", "event ImplementationPolicySet(address indexed owner, bytes32 indexed contractType, uint32 indexed version, bool cloneable, bool initRequired, bytes4 initSelector)", "function deployContract(address implementationOwner, bytes32 contractType, bytes initData) returns (address)", "function deployContractByVersion(address implementationOwner, bytes32 contractType, uint32 version, bytes initData) returns (address)", "function deployedContracts(address owner, uint256 index) view returns (address)"];

type Address = string;
type Bytes32 = string;
interface FactoryConnectionOptions {
    chainId?: number;
    factoryAddress?: Address;
    rpcUrl?: string;
    signer?: Signer;
    provider?: Provider;
    privateKey?: string;
}
interface DeployContractOptions extends FactoryConnectionOptions {
    abi: InterfaceAbi;
    bytecode: BytesLike;
    args?: readonly unknown[];
}
interface DeployContractResult {
    address: Address;
    txHash: string;
    receipt: TransactionReceipt;
}
interface SetImplementationOptions extends FactoryConnectionOptions {
    implementation: Address;
    contractType: string;
    initSignature?: string;
}
interface SetImplementationResult {
    factoryAddress: Address;
    implementation: Address;
    contractType: string;
    contractTypeHash: Bytes32;
    version: number;
    initSelector?: string;
    policy?: {
        cloneable: boolean;
        initRequired: boolean;
        initSelector: string;
    };
    txHash: string;
    receipt: TransactionReceipt;
}
interface DeployViaFactoryOptions extends FactoryConnectionOptions {
    implementationOwner: Address;
    contractType: string;
    fnSignature: string;
    fnArgs?: readonly unknown[];
}
interface DeployViaFactoryByVersionOptions extends DeployViaFactoryOptions {
    version: BigNumberish;
}
interface DeployViaFactoryResult {
    factoryAddress: Address;
    implementationOwner: Address;
    contractType: string;
    contractTypeHash: Bytes32;
    initData: string;
    proxy: Address;
    predictedProxy?: Address;
    txHash: string;
    receipt: TransactionReceipt;
}
interface ImplementationPolicy {
    isSet: boolean;
    cloneable: boolean;
    initRequired: boolean;
    initSelector: string;
}
interface GetImplementationPolicyOptions extends FactoryConnectionOptions {
    owner: Address;
    contractType: string;
    version: BigNumberish;
}
interface GetLatestImplementationOptions extends FactoryConnectionOptions {
    owner: Address;
    contractType: string;
}
interface GetImplementationByVersionOptions extends GetLatestImplementationOptions {
    version: BigNumberish;
}
interface ImplementationVersion {
    implementation: Address;
    timestamp: bigint;
}
interface GetDeployedContractOptions extends FactoryConnectionOptions {
    owner: Address;
    index: BigNumberish;
}
declare function getContractTypeHash(contractType: string): Bytes32;
declare function getInitSelector(initSignature: string): string;
declare function encodeInitData(fnSignature: string, fnArgs?: readonly unknown[]): string;
declare function resolveRpcUrl(chainId?: number, rpcUrl?: string): string;
declare function resolveFactoryAddress(chainId?: number, factoryAddress?: Address): Address;
declare function getFactoryContract(options: FactoryConnectionOptions): ethers.Contract;
declare function createSigner(options: FactoryConnectionOptions): Promise<Signer>;
declare function createProvider(options: FactoryConnectionOptions): Provider;
/**
 * Verify the RPC the provider is actually connected to matches the requested
 * chainId before any signing/broadcasting. Without this, a mismatched RPC URL
 * (e.g. a generic RPC_URL set for another network, or a wrong --rpcUrl) would
 * cause the deployer key to sign and broadcast a real transaction on the wrong
 * chain. No-op when chainId is not specified or the provider is absent.
 */
declare function assertChainId(provider: Provider | null | undefined, expected?: number): Promise<void>;
declare function deployContract(options: DeployContractOptions): Promise<DeployContractResult>;
declare function setImplementation(options: SetImplementationOptions): Promise<SetImplementationResult>;
declare function deployViaFactory(options: DeployViaFactoryOptions): Promise<DeployViaFactoryResult>;
declare function deployViaFactoryByVersion(options: DeployViaFactoryByVersionOptions): Promise<DeployViaFactoryResult>;
declare function getLatestImplementation(options: GetLatestImplementationOptions): Promise<Address>;
declare function getImplementationByVersion(options: GetImplementationByVersionOptions): Promise<ImplementationVersion>;
declare function getImplementationPolicy(options: GetImplementationPolicyOptions): Promise<ImplementationPolicy>;
declare function getDeployedContract(options: GetDeployedContractOptions): Promise<Address>;

export { type Address, type Bytes32, type DeployContractOptions, type DeployContractResult, type DeployViaFactoryByVersionOptions, type DeployViaFactoryOptions, type DeployViaFactoryResult, FACTORY_ADDRESS, FactoryABI, type FactoryConnectionOptions, type GetDeployedContractOptions, type GetImplementationByVersionOptions, type GetImplementationPolicyOptions, type GetLatestImplementationOptions, type ImplementationPolicy, type ImplementationVersion, RPC_URLs, type SetImplementationOptions, type SetImplementationResult, assertChainId, createProvider, createSigner, deployContract, deployViaFactory, deployViaFactoryByVersion, encodeInitData, getContractTypeHash, getDeployedContract, getFactoryContract, getImplementationByVersion, getImplementationPolicy, getInitSelector, getLatestImplementation, resolveFactoryAddress, resolveRpcUrl, setImplementation };