import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
import type { Listener, Provider } from "@ethersproject/providers";
import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
export interface AllocationStrategyFactoryAbiInterface extends utils.Interface {
    functions: {
        "createInstance(bytes,bytes32)": FunctionFragment;
        "defaultImplementation()": FunctionFragment;
        "defaultVersion()": FunctionFragment;
        "disableUpgradePath(uint256,uint256)": FunctionFragment;
        "enableUpgradePath(uint256,uint256,address)": FunctionFragment;
        "getInstanceAddress(bytes,bytes32)": FunctionFragment;
        "implementationOf(uint256)": FunctionFragment;
        "isInstance(address)": FunctionFragment;
        "mapleGlobals()": FunctionFragment;
        "migratorForPath(uint256,uint256)": FunctionFragment;
        "registerImplementation(uint256,address,address)": FunctionFragment;
        "setDefaultVersion(uint256)": FunctionFragment;
        "setGlobals(address)": FunctionFragment;
        "upgradeEnabledForPath(uint256,uint256)": FunctionFragment;
        "upgradeInstance(uint256,bytes)": FunctionFragment;
        "versionOf(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "createInstance" | "defaultImplementation" | "defaultVersion" | "disableUpgradePath" | "enableUpgradePath" | "getInstanceAddress" | "implementationOf" | "isInstance" | "mapleGlobals" | "migratorForPath" | "registerImplementation" | "setDefaultVersion" | "setGlobals" | "upgradeEnabledForPath" | "upgradeInstance" | "versionOf"): FunctionFragment;
    encodeFunctionData(functionFragment: "createInstance", values: [BytesLike, BytesLike]): string;
    encodeFunctionData(functionFragment: "defaultImplementation", values?: undefined): string;
    encodeFunctionData(functionFragment: "defaultVersion", values?: undefined): string;
    encodeFunctionData(functionFragment: "disableUpgradePath", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "enableUpgradePath", values: [BigNumberish, BigNumberish, string]): string;
    encodeFunctionData(functionFragment: "getInstanceAddress", values: [BytesLike, BytesLike]): string;
    encodeFunctionData(functionFragment: "implementationOf", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "isInstance", values: [string]): string;
    encodeFunctionData(functionFragment: "mapleGlobals", values?: undefined): string;
    encodeFunctionData(functionFragment: "migratorForPath", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "registerImplementation", values: [BigNumberish, string, string]): string;
    encodeFunctionData(functionFragment: "setDefaultVersion", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setGlobals", values: [string]): string;
    encodeFunctionData(functionFragment: "upgradeEnabledForPath", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "upgradeInstance", values: [BigNumberish, BytesLike]): string;
    encodeFunctionData(functionFragment: "versionOf", values: [string]): string;
    decodeFunctionResult(functionFragment: "createInstance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultImplementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "defaultVersion", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "disableUpgradePath", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "enableUpgradePath", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getInstanceAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "implementationOf", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isInstance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "mapleGlobals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "migratorForPath", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "registerImplementation", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setDefaultVersion", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setGlobals", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgradeEnabledForPath", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "upgradeInstance", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "versionOf", data: BytesLike): Result;
    events: {
        "DefaultVersionSet(uint256)": EventFragment;
        "ImplementationRegistered(uint256,address,address)": EventFragment;
        "InstanceDeployed(uint256,address,bytes)": EventFragment;
        "InstanceUpgraded(address,uint256,uint256,bytes)": EventFragment;
        "MapleGlobalsSet(address)": EventFragment;
        "UpgradePathDisabled(uint256,uint256)": EventFragment;
        "UpgradePathEnabled(uint256,uint256,address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "DefaultVersionSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "ImplementationRegistered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "InstanceDeployed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "InstanceUpgraded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "MapleGlobalsSet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UpgradePathDisabled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "UpgradePathEnabled"): EventFragment;
}
export interface DefaultVersionSetEventObject {
    version_: BigNumber;
}
export type DefaultVersionSetEvent = TypedEvent<[
    BigNumber
], DefaultVersionSetEventObject>;
export type DefaultVersionSetEventFilter = TypedEventFilter<DefaultVersionSetEvent>;
export interface ImplementationRegisteredEventObject {
    version_: BigNumber;
    implementationAddress_: string;
    initializer_: string;
}
export type ImplementationRegisteredEvent = TypedEvent<[
    BigNumber,
    string,
    string
], ImplementationRegisteredEventObject>;
export type ImplementationRegisteredEventFilter = TypedEventFilter<ImplementationRegisteredEvent>;
export interface InstanceDeployedEventObject {
    version_: BigNumber;
    instance_: string;
    initializationArguments_: string;
}
export type InstanceDeployedEvent = TypedEvent<[
    BigNumber,
    string,
    string
], InstanceDeployedEventObject>;
export type InstanceDeployedEventFilter = TypedEventFilter<InstanceDeployedEvent>;
export interface InstanceUpgradedEventObject {
    instance_: string;
    fromVersion_: BigNumber;
    toVersion_: BigNumber;
    migrationArguments_: string;
}
export type InstanceUpgradedEvent = TypedEvent<[
    string,
    BigNumber,
    BigNumber,
    string
], InstanceUpgradedEventObject>;
export type InstanceUpgradedEventFilter = TypedEventFilter<InstanceUpgradedEvent>;
export interface MapleGlobalsSetEventObject {
    mapleGlobals_: string;
}
export type MapleGlobalsSetEvent = TypedEvent<[
    string
], MapleGlobalsSetEventObject>;
export type MapleGlobalsSetEventFilter = TypedEventFilter<MapleGlobalsSetEvent>;
export interface UpgradePathDisabledEventObject {
    fromVersion_: BigNumber;
    toVersion_: BigNumber;
}
export type UpgradePathDisabledEvent = TypedEvent<[
    BigNumber,
    BigNumber
], UpgradePathDisabledEventObject>;
export type UpgradePathDisabledEventFilter = TypedEventFilter<UpgradePathDisabledEvent>;
export interface UpgradePathEnabledEventObject {
    fromVersion_: BigNumber;
    toVersion_: BigNumber;
    migrator_: string;
}
export type UpgradePathEnabledEvent = TypedEvent<[
    BigNumber,
    BigNumber,
    string
], UpgradePathEnabledEventObject>;
export type UpgradePathEnabledEventFilter = TypedEventFilter<UpgradePathEnabledEvent>;
export interface AllocationStrategyFactoryAbi extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: AllocationStrategyFactoryAbiInterface;
    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
    listeners(eventName?: string): Array<Listener>;
    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
    removeAllListeners(eventName?: string): this;
    off: OnEvent<this>;
    on: OnEvent<this>;
    once: OnEvent<this>;
    removeListener: OnEvent<this>;
    functions: {
        createInstance(arguments_: BytesLike, salt_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        defaultImplementation(overrides?: CallOverrides): Promise<[string] & {
            defaultImplementation_: string;
        }>;
        defaultVersion(overrides?: CallOverrides): Promise<[BigNumber]>;
        disableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        enableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, migrator_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        getInstanceAddress(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<[string] & {
            instanceAddress_: string;
        }>;
        implementationOf(version_: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
            implementation_: string;
        }>;
        isInstance(arg0: string, overrides?: CallOverrides): Promise<[boolean]>;
        mapleGlobals(overrides?: CallOverrides): Promise<[string]>;
        migratorForPath(oldVersion_: BigNumberish, newVersion_: BigNumberish, overrides?: CallOverrides): Promise<[string] & {
            migrator_: string;
        }>;
        registerImplementation(version_: BigNumberish, implementationAddress_: string, initializer_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setDefaultVersion(version_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setGlobals(mapleGlobals_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        upgradeEnabledForPath(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
        upgradeInstance(toVersion_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        versionOf(implementation_: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            version_: BigNumber;
        }>;
    };
    createInstance(arguments_: BytesLike, salt_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    defaultImplementation(overrides?: CallOverrides): Promise<string>;
    defaultVersion(overrides?: CallOverrides): Promise<BigNumber>;
    disableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    enableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, migrator_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    getInstanceAddress(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<string>;
    implementationOf(version_: BigNumberish, overrides?: CallOverrides): Promise<string>;
    isInstance(arg0: string, overrides?: CallOverrides): Promise<boolean>;
    mapleGlobals(overrides?: CallOverrides): Promise<string>;
    migratorForPath(oldVersion_: BigNumberish, newVersion_: BigNumberish, overrides?: CallOverrides): Promise<string>;
    registerImplementation(version_: BigNumberish, implementationAddress_: string, initializer_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setDefaultVersion(version_: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setGlobals(mapleGlobals_: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    upgradeEnabledForPath(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
    upgradeInstance(toVersion_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    versionOf(implementation_: string, overrides?: CallOverrides): Promise<BigNumber>;
    callStatic: {
        createInstance(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<string>;
        defaultImplementation(overrides?: CallOverrides): Promise<string>;
        defaultVersion(overrides?: CallOverrides): Promise<BigNumber>;
        disableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        enableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, migrator_: string, overrides?: CallOverrides): Promise<void>;
        getInstanceAddress(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<string>;
        implementationOf(version_: BigNumberish, overrides?: CallOverrides): Promise<string>;
        isInstance(arg0: string, overrides?: CallOverrides): Promise<boolean>;
        mapleGlobals(overrides?: CallOverrides): Promise<string>;
        migratorForPath(oldVersion_: BigNumberish, newVersion_: BigNumberish, overrides?: CallOverrides): Promise<string>;
        registerImplementation(version_: BigNumberish, implementationAddress_: string, initializer_: string, overrides?: CallOverrides): Promise<void>;
        setDefaultVersion(version_: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setGlobals(mapleGlobals_: string, overrides?: CallOverrides): Promise<void>;
        upgradeEnabledForPath(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        upgradeInstance(toVersion_: BigNumberish, arguments_: BytesLike, overrides?: CallOverrides): Promise<void>;
        versionOf(implementation_: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    filters: {
        "DefaultVersionSet(uint256)"(version_?: BigNumberish | null): DefaultVersionSetEventFilter;
        DefaultVersionSet(version_?: BigNumberish | null): DefaultVersionSetEventFilter;
        "ImplementationRegistered(uint256,address,address)"(version_?: BigNumberish | null, implementationAddress_?: string | null, initializer_?: string | null): ImplementationRegisteredEventFilter;
        ImplementationRegistered(version_?: BigNumberish | null, implementationAddress_?: string | null, initializer_?: string | null): ImplementationRegisteredEventFilter;
        "InstanceDeployed(uint256,address,bytes)"(version_?: BigNumberish | null, instance_?: string | null, initializationArguments_?: null): InstanceDeployedEventFilter;
        InstanceDeployed(version_?: BigNumberish | null, instance_?: string | null, initializationArguments_?: null): InstanceDeployedEventFilter;
        "InstanceUpgraded(address,uint256,uint256,bytes)"(instance_?: string | null, fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null, migrationArguments_?: null): InstanceUpgradedEventFilter;
        InstanceUpgraded(instance_?: string | null, fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null, migrationArguments_?: null): InstanceUpgradedEventFilter;
        "MapleGlobalsSet(address)"(mapleGlobals_?: string | null): MapleGlobalsSetEventFilter;
        MapleGlobalsSet(mapleGlobals_?: string | null): MapleGlobalsSetEventFilter;
        "UpgradePathDisabled(uint256,uint256)"(fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null): UpgradePathDisabledEventFilter;
        UpgradePathDisabled(fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null): UpgradePathDisabledEventFilter;
        "UpgradePathEnabled(uint256,uint256,address)"(fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null, migrator_?: string | null): UpgradePathEnabledEventFilter;
        UpgradePathEnabled(fromVersion_?: BigNumberish | null, toVersion_?: BigNumberish | null, migrator_?: string | null): UpgradePathEnabledEventFilter;
    };
    estimateGas: {
        createInstance(arguments_: BytesLike, salt_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        defaultImplementation(overrides?: CallOverrides): Promise<BigNumber>;
        defaultVersion(overrides?: CallOverrides): Promise<BigNumber>;
        disableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        enableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, migrator_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        getInstanceAddress(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        implementationOf(version_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        isInstance(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        mapleGlobals(overrides?: CallOverrides): Promise<BigNumber>;
        migratorForPath(oldVersion_: BigNumberish, newVersion_: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        registerImplementation(version_: BigNumberish, implementationAddress_: string, initializer_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setDefaultVersion(version_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setGlobals(mapleGlobals_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        upgradeEnabledForPath(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        upgradeInstance(toVersion_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        versionOf(implementation_: string, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        createInstance(arguments_: BytesLike, salt_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        defaultImplementation(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        defaultVersion(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        disableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        enableUpgradePath(fromVersion_: BigNumberish, toVersion_: BigNumberish, migrator_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        getInstanceAddress(arguments_: BytesLike, salt_: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        implementationOf(version_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isInstance(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        mapleGlobals(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        migratorForPath(oldVersion_: BigNumberish, newVersion_: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        registerImplementation(version_: BigNumberish, implementationAddress_: string, initializer_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setDefaultVersion(version_: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setGlobals(mapleGlobals_: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        upgradeEnabledForPath(arg0: BigNumberish, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        upgradeInstance(toVersion_: BigNumberish, arguments_: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        versionOf(implementation_: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}