import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PayableOverrides, 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, PromiseOrValue } from "../common";
export declare namespace IForwarder {
    type DeployRequestStruct = {
        relayHub: PromiseOrValue<string>;
        from: PromiseOrValue<string>;
        to: PromiseOrValue<string>;
        tokenContract: PromiseOrValue<string>;
        recoverer: PromiseOrValue<string>;
        value: PromiseOrValue<BigNumberish>;
        nonce: PromiseOrValue<BigNumberish>;
        tokenAmount: PromiseOrValue<BigNumberish>;
        tokenGas: PromiseOrValue<BigNumberish>;
        validUntilTime: PromiseOrValue<BigNumberish>;
        index: PromiseOrValue<BigNumberish>;
        data: PromiseOrValue<BytesLike>;
    };
    type DeployRequestStructOutput = [
        string,
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string
    ] & {
        relayHub: string;
        from: string;
        to: string;
        tokenContract: string;
        recoverer: string;
        value: BigNumber;
        nonce: BigNumber;
        tokenAmount: BigNumber;
        tokenGas: BigNumber;
        validUntilTime: BigNumber;
        index: BigNumber;
        data: string;
    };
    type ForwardRequestStruct = {
        relayHub: PromiseOrValue<string>;
        from: PromiseOrValue<string>;
        to: PromiseOrValue<string>;
        tokenContract: PromiseOrValue<string>;
        value: PromiseOrValue<BigNumberish>;
        gas: PromiseOrValue<BigNumberish>;
        nonce: PromiseOrValue<BigNumberish>;
        tokenAmount: PromiseOrValue<BigNumberish>;
        tokenGas: PromiseOrValue<BigNumberish>;
        validUntilTime: PromiseOrValue<BigNumberish>;
        data: PromiseOrValue<BytesLike>;
    };
    type ForwardRequestStructOutput = [
        string,
        string,
        string,
        string,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        BigNumber,
        string
    ] & {
        relayHub: string;
        from: string;
        to: string;
        tokenContract: string;
        value: BigNumber;
        gas: BigNumber;
        nonce: BigNumber;
        tokenAmount: BigNumber;
        tokenGas: BigNumber;
        validUntilTime: BigNumber;
        data: string;
    };
}
export declare namespace EnvelopingTypes {
    type RelayDataStruct = {
        gasPrice: PromiseOrValue<BigNumberish>;
        feesReceiver: PromiseOrValue<string>;
        callForwarder: PromiseOrValue<string>;
        callVerifier: PromiseOrValue<string>;
    };
    type RelayDataStructOutput = [BigNumber, string, string, string] & {
        gasPrice: BigNumber;
        feesReceiver: string;
        callForwarder: string;
        callVerifier: string;
    };
    type DeployRequestStruct = {
        request: IForwarder.DeployRequestStruct;
        relayData: EnvelopingTypes.RelayDataStruct;
    };
    type DeployRequestStructOutput = [
        IForwarder.DeployRequestStructOutput,
        EnvelopingTypes.RelayDataStructOutput
    ] & {
        request: IForwarder.DeployRequestStructOutput;
        relayData: EnvelopingTypes.RelayDataStructOutput;
    };
    type RelayRequestStruct = {
        request: IForwarder.ForwardRequestStruct;
        relayData: EnvelopingTypes.RelayDataStruct;
    };
    type RelayRequestStructOutput = [
        IForwarder.ForwardRequestStructOutput,
        EnvelopingTypes.RelayDataStructOutput
    ] & {
        request: IForwarder.ForwardRequestStructOutput;
        relayData: EnvelopingTypes.RelayDataStructOutput;
    };
}
export declare namespace IRelayHub {
    type RelayManagerDataStruct = {
        manager: PromiseOrValue<string>;
        currentlyStaked: PromiseOrValue<boolean>;
        registered: PromiseOrValue<boolean>;
        url: PromiseOrValue<string>;
    };
    type RelayManagerDataStructOutput = [
        string,
        boolean,
        boolean,
        string
    ] & {
        manager: string;
        currentlyStaked: boolean;
        registered: boolean;
        url: string;
    };
    type StakeInfoStruct = {
        stake: PromiseOrValue<BigNumberish>;
        unstakeDelay: PromiseOrValue<BigNumberish>;
        withdrawBlock: PromiseOrValue<BigNumberish>;
        owner: PromiseOrValue<string>;
    };
    type StakeInfoStructOutput = [
        BigNumber,
        BigNumber,
        BigNumber,
        string
    ] & {
        stake: BigNumber;
        unstakeDelay: BigNumber;
        withdrawBlock: BigNumber;
        owner: string;
    };
}
export interface RelayHubInterface extends utils.Interface {
    functions: {
        "addRelayWorkers(address[])": FunctionFragment;
        "deployCall(((address,address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes),(uint256,address,address,address)),bytes)": FunctionFragment;
        "disableRelayWorkers(address[])": FunctionFragment;
        "getRelayInfo(address)": FunctionFragment;
        "getStakeInfo(address)": FunctionFragment;
        "isRelayManagerStaked(address)": FunctionFragment;
        "maxWorkerCount()": FunctionFragment;
        "minimumEntryDepositValue()": FunctionFragment;
        "minimumStake()": FunctionFragment;
        "minimumUnstakeDelay()": FunctionFragment;
        "penalize(address,address)": FunctionFragment;
        "penalizer()": FunctionFragment;
        "registerRelayServer(string)": FunctionFragment;
        "relayCall(((address,address,address,address,uint256,uint256,uint256,uint256,uint256,uint256,bytes),(uint256,address,address,address)),bytes)": FunctionFragment;
        "relayData(address)": FunctionFragment;
        "stakeForAddress(address,uint256)": FunctionFragment;
        "stakes(address)": FunctionFragment;
        "unlockStake(address)": FunctionFragment;
        "versionHub()": FunctionFragment;
        "withdrawStake(address)": FunctionFragment;
        "workerCount(address)": FunctionFragment;
        "workerToManager(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "addRelayWorkers" | "deployCall" | "disableRelayWorkers" | "getRelayInfo" | "getStakeInfo" | "isRelayManagerStaked" | "maxWorkerCount" | "minimumEntryDepositValue" | "minimumStake" | "minimumUnstakeDelay" | "penalize" | "penalizer" | "registerRelayServer" | "relayCall" | "relayData" | "stakeForAddress" | "stakes" | "unlockStake" | "versionHub" | "withdrawStake" | "workerCount" | "workerToManager"): FunctionFragment;
    encodeFunctionData(functionFragment: "addRelayWorkers", values: [PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "deployCall", values: [EnvelopingTypes.DeployRequestStruct, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "disableRelayWorkers", values: [PromiseOrValue<string>[]]): string;
    encodeFunctionData(functionFragment: "getRelayInfo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "getStakeInfo", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "isRelayManagerStaked", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "maxWorkerCount", values?: undefined): string;
    encodeFunctionData(functionFragment: "minimumEntryDepositValue", values?: undefined): string;
    encodeFunctionData(functionFragment: "minimumStake", values?: undefined): string;
    encodeFunctionData(functionFragment: "minimumUnstakeDelay", values?: undefined): string;
    encodeFunctionData(functionFragment: "penalize", values: [PromiseOrValue<string>, PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "penalizer", values?: undefined): string;
    encodeFunctionData(functionFragment: "registerRelayServer", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "relayCall", values: [EnvelopingTypes.RelayRequestStruct, PromiseOrValue<BytesLike>]): string;
    encodeFunctionData(functionFragment: "relayData", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "stakeForAddress", values: [PromiseOrValue<string>, PromiseOrValue<BigNumberish>]): string;
    encodeFunctionData(functionFragment: "stakes", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "unlockStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "versionHub", values?: undefined): string;
    encodeFunctionData(functionFragment: "withdrawStake", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "workerCount", values: [PromiseOrValue<string>]): string;
    encodeFunctionData(functionFragment: "workerToManager", values: [PromiseOrValue<string>]): string;
    decodeFunctionResult(functionFragment: "addRelayWorkers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "deployCall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "disableRelayWorkers", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getRelayInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "getStakeInfo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "isRelayManagerStaked", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "maxWorkerCount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "minimumEntryDepositValue", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "minimumStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "minimumUnstakeDelay", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "penalize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "penalizer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "registerRelayServer", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "relayCall", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "relayData", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakeForAddress", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakes", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "unlockStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "versionHub", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "withdrawStake", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "workerCount", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "workerToManager", data: BytesLike): Result;
    events: {
        "Penalized(address,address,uint256)": EventFragment;
        "RelayServerRegistered(address,string)": EventFragment;
        "RelayWorkersAdded(address,address[],uint256)": EventFragment;
        "RelayWorkersDisabled(address,address[],uint256)": EventFragment;
        "StakeAdded(address,address,uint256,uint256)": EventFragment;
        "StakePenalized(address,address,uint256)": EventFragment;
        "StakeUnlocked(address,address,uint256)": EventFragment;
        "StakeWithdrawn(address,address,uint256)": EventFragment;
        "TransactionRelayed(address,address,bytes32,bytes)": EventFragment;
        "TransactionRelayedButRevertedByRecipient(address,address,bytes32,bytes)": EventFragment;
        "TransactionResult(bytes)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Penalized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RelayServerRegistered"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RelayWorkersAdded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "RelayWorkersDisabled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeAdded"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakePenalized"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeUnlocked"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "StakeWithdrawn"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TransactionRelayed"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TransactionRelayedButRevertedByRecipient"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "TransactionResult"): EventFragment;
}
export interface PenalizedEventObject {
    relayWorker: string;
    sender: string;
    reward: BigNumber;
}
export declare type PenalizedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], PenalizedEventObject>;
export declare type PenalizedEventFilter = TypedEventFilter<PenalizedEvent>;
export interface RelayServerRegisteredEventObject {
    relayManager: string;
    relayUrl: string;
}
export declare type RelayServerRegisteredEvent = TypedEvent<[
    string,
    string
], RelayServerRegisteredEventObject>;
export declare type RelayServerRegisteredEventFilter = TypedEventFilter<RelayServerRegisteredEvent>;
export interface RelayWorkersAddedEventObject {
    relayManager: string;
    newRelayWorkers: string[];
    workersCount: BigNumber;
}
export declare type RelayWorkersAddedEvent = TypedEvent<[
    string,
    string[],
    BigNumber
], RelayWorkersAddedEventObject>;
export declare type RelayWorkersAddedEventFilter = TypedEventFilter<RelayWorkersAddedEvent>;
export interface RelayWorkersDisabledEventObject {
    relayManager: string;
    relayWorkers: string[];
    workersCount: BigNumber;
}
export declare type RelayWorkersDisabledEvent = TypedEvent<[
    string,
    string[],
    BigNumber
], RelayWorkersDisabledEventObject>;
export declare type RelayWorkersDisabledEventFilter = TypedEventFilter<RelayWorkersDisabledEvent>;
export interface StakeAddedEventObject {
    relayManager: string;
    owner: string;
    stake: BigNumber;
    unstakeDelay: BigNumber;
}
export declare type StakeAddedEvent = TypedEvent<[
    string,
    string,
    BigNumber,
    BigNumber
], StakeAddedEventObject>;
export declare type StakeAddedEventFilter = TypedEventFilter<StakeAddedEvent>;
export interface StakePenalizedEventObject {
    relayManager: string;
    beneficiary: string;
    reward: BigNumber;
}
export declare type StakePenalizedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StakePenalizedEventObject>;
export declare type StakePenalizedEventFilter = TypedEventFilter<StakePenalizedEvent>;
export interface StakeUnlockedEventObject {
    relayManager: string;
    owner: string;
    withdrawBlock: BigNumber;
}
export declare type StakeUnlockedEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StakeUnlockedEventObject>;
export declare type StakeUnlockedEventFilter = TypedEventFilter<StakeUnlockedEvent>;
export interface StakeWithdrawnEventObject {
    relayManager: string;
    owner: string;
    amount: BigNumber;
}
export declare type StakeWithdrawnEvent = TypedEvent<[
    string,
    string,
    BigNumber
], StakeWithdrawnEventObject>;
export declare type StakeWithdrawnEventFilter = TypedEventFilter<StakeWithdrawnEvent>;
export interface TransactionRelayedEventObject {
    relayManager: string;
    relayWorker: string;
    relayRequestSigHash: string;
    relayedCallReturnValue: string;
}
export declare type TransactionRelayedEvent = TypedEvent<[
    string,
    string,
    string,
    string
], TransactionRelayedEventObject>;
export declare type TransactionRelayedEventFilter = TypedEventFilter<TransactionRelayedEvent>;
export interface TransactionRelayedButRevertedByRecipientEventObject {
    relayManager: string;
    relayWorker: string;
    relayRequestSigHash: string;
    reason: string;
}
export declare type TransactionRelayedButRevertedByRecipientEvent = TypedEvent<[
    string,
    string,
    string,
    string
], TransactionRelayedButRevertedByRecipientEventObject>;
export declare type TransactionRelayedButRevertedByRecipientEventFilter = TypedEventFilter<TransactionRelayedButRevertedByRecipientEvent>;
export interface TransactionResultEventObject {
    returnValue: string;
}
export declare type TransactionResultEvent = TypedEvent<[
    string
], TransactionResultEventObject>;
export declare type TransactionResultEventFilter = TypedEventFilter<TransactionResultEvent>;
export interface RelayHub extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: RelayHubInterface;
    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: {
        addRelayWorkers(newRelayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        deployCall(deployRequest: EnvelopingTypes.DeployRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        disableRelayWorkers(relayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        getRelayInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            IRelayHub.RelayManagerDataStructOutput
        ] & {
            relayManagerData: IRelayHub.RelayManagerDataStructOutput;
        }>;
        getStakeInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            IRelayHub.StakeInfoStructOutput
        ] & {
            stakeInfo: IRelayHub.StakeInfoStructOutput;
        }>;
        isRelayManagerStaked(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
        maxWorkerCount(overrides?: CallOverrides): Promise<[BigNumber]>;
        minimumEntryDepositValue(overrides?: CallOverrides): Promise<[BigNumber]>;
        minimumStake(overrides?: CallOverrides): Promise<[BigNumber]>;
        minimumUnstakeDelay(overrides?: CallOverrides): Promise<[BigNumber]>;
        penalize(relayWorker: PromiseOrValue<string>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        penalizer(overrides?: CallOverrides): Promise<[string]>;
        registerRelayServer(url: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        relayCall(relayRequest: EnvelopingTypes.RelayRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        relayData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            boolean,
            boolean,
            string
        ] & {
            manager: string;
            currentlyStaked: boolean;
            registered: boolean;
            url: string;
        }>;
        stakeForAddress(relayManager: PromiseOrValue<string>, unstakeDelay: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        stakes(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            string
        ] & {
            stake: BigNumber;
            unstakeDelay: BigNumber;
            withdrawBlock: BigNumber;
            owner: string;
        }>;
        unlockStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        versionHub(overrides?: CallOverrides): Promise<[string]>;
        withdrawStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<ContractTransaction>;
        workerCount(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[BigNumber]>;
        workerToManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[string]>;
    };
    addRelayWorkers(newRelayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    deployCall(deployRequest: EnvelopingTypes.DeployRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    disableRelayWorkers(relayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    getRelayInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IRelayHub.RelayManagerDataStructOutput>;
    getStakeInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IRelayHub.StakeInfoStructOutput>;
    isRelayManagerStaked(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
    maxWorkerCount(overrides?: CallOverrides): Promise<BigNumber>;
    minimumEntryDepositValue(overrides?: CallOverrides): Promise<BigNumber>;
    minimumStake(overrides?: CallOverrides): Promise<BigNumber>;
    minimumUnstakeDelay(overrides?: CallOverrides): Promise<BigNumber>;
    penalize(relayWorker: PromiseOrValue<string>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    penalizer(overrides?: CallOverrides): Promise<string>;
    registerRelayServer(url: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    relayCall(relayRequest: EnvelopingTypes.RelayRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    relayData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        string,
        boolean,
        boolean,
        string
    ] & {
        manager: string;
        currentlyStaked: boolean;
        registered: boolean;
        url: string;
    }>;
    stakeForAddress(relayManager: PromiseOrValue<string>, unstakeDelay: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    stakes(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
        BigNumber,
        BigNumber,
        BigNumber,
        string
    ] & {
        stake: BigNumber;
        unstakeDelay: BigNumber;
        withdrawBlock: BigNumber;
        owner: string;
    }>;
    unlockStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    versionHub(overrides?: CallOverrides): Promise<string>;
    withdrawStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
        from?: PromiseOrValue<string>;
    }): Promise<ContractTransaction>;
    workerCount(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    workerToManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    callStatic: {
        addRelayWorkers(newRelayWorkers: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        deployCall(deployRequest: EnvelopingTypes.DeployRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<void>;
        disableRelayWorkers(relayWorkers: PromiseOrValue<string>[], overrides?: CallOverrides): Promise<void>;
        getRelayInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IRelayHub.RelayManagerDataStructOutput>;
        getStakeInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<IRelayHub.StakeInfoStructOutput>;
        isRelayManagerStaked(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
        maxWorkerCount(overrides?: CallOverrides): Promise<BigNumber>;
        minimumEntryDepositValue(overrides?: CallOverrides): Promise<BigNumber>;
        minimumStake(overrides?: CallOverrides): Promise<BigNumber>;
        minimumUnstakeDelay(overrides?: CallOverrides): Promise<BigNumber>;
        penalize(relayWorker: PromiseOrValue<string>, beneficiary: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        penalizer(overrides?: CallOverrides): Promise<string>;
        registerRelayServer(url: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        relayCall(relayRequest: EnvelopingTypes.RelayRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: CallOverrides): Promise<boolean>;
        relayData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            string,
            boolean,
            boolean,
            string
        ] & {
            manager: string;
            currentlyStaked: boolean;
            registered: boolean;
            url: string;
        }>;
        stakeForAddress(relayManager: PromiseOrValue<string>, unstakeDelay: PromiseOrValue<BigNumberish>, overrides?: CallOverrides): Promise<void>;
        stakes(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[
            BigNumber,
            BigNumber,
            BigNumber,
            string
        ] & {
            stake: BigNumber;
            unstakeDelay: BigNumber;
            withdrawBlock: BigNumber;
            owner: string;
        }>;
        unlockStake(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        versionHub(overrides?: CallOverrides): Promise<string>;
        withdrawStake(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
        workerCount(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        workerToManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<string>;
    };
    filters: {
        "Penalized(address,address,uint256)"(relayWorker?: PromiseOrValue<string> | null, sender?: null, reward?: null): PenalizedEventFilter;
        Penalized(relayWorker?: PromiseOrValue<string> | null, sender?: null, reward?: null): PenalizedEventFilter;
        "RelayServerRegistered(address,string)"(relayManager?: PromiseOrValue<string> | null, relayUrl?: null): RelayServerRegisteredEventFilter;
        RelayServerRegistered(relayManager?: PromiseOrValue<string> | null, relayUrl?: null): RelayServerRegisteredEventFilter;
        "RelayWorkersAdded(address,address[],uint256)"(relayManager?: PromiseOrValue<string> | null, newRelayWorkers?: null, workersCount?: null): RelayWorkersAddedEventFilter;
        RelayWorkersAdded(relayManager?: PromiseOrValue<string> | null, newRelayWorkers?: null, workersCount?: null): RelayWorkersAddedEventFilter;
        "RelayWorkersDisabled(address,address[],uint256)"(relayManager?: PromiseOrValue<string> | null, relayWorkers?: null, workersCount?: null): RelayWorkersDisabledEventFilter;
        RelayWorkersDisabled(relayManager?: PromiseOrValue<string> | null, relayWorkers?: null, workersCount?: null): RelayWorkersDisabledEventFilter;
        "StakeAdded(address,address,uint256,uint256)"(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, stake?: null, unstakeDelay?: null): StakeAddedEventFilter;
        StakeAdded(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, stake?: null, unstakeDelay?: null): StakeAddedEventFilter;
        "StakePenalized(address,address,uint256)"(relayManager?: PromiseOrValue<string> | null, beneficiary?: PromiseOrValue<string> | null, reward?: null): StakePenalizedEventFilter;
        StakePenalized(relayManager?: PromiseOrValue<string> | null, beneficiary?: PromiseOrValue<string> | null, reward?: null): StakePenalizedEventFilter;
        "StakeUnlocked(address,address,uint256)"(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, withdrawBlock?: null): StakeUnlockedEventFilter;
        StakeUnlocked(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, withdrawBlock?: null): StakeUnlockedEventFilter;
        "StakeWithdrawn(address,address,uint256)"(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawnEventFilter;
        StakeWithdrawn(relayManager?: PromiseOrValue<string> | null, owner?: PromiseOrValue<string> | null, amount?: null): StakeWithdrawnEventFilter;
        "TransactionRelayed(address,address,bytes32,bytes)"(relayManager?: PromiseOrValue<string> | null, relayWorker?: null, relayRequestSigHash?: null, relayedCallReturnValue?: null): TransactionRelayedEventFilter;
        TransactionRelayed(relayManager?: PromiseOrValue<string> | null, relayWorker?: null, relayRequestSigHash?: null, relayedCallReturnValue?: null): TransactionRelayedEventFilter;
        "TransactionRelayedButRevertedByRecipient(address,address,bytes32,bytes)"(relayManager?: PromiseOrValue<string> | null, relayWorker?: null, relayRequestSigHash?: null, reason?: null): TransactionRelayedButRevertedByRecipientEventFilter;
        TransactionRelayedButRevertedByRecipient(relayManager?: PromiseOrValue<string> | null, relayWorker?: null, relayRequestSigHash?: null, reason?: null): TransactionRelayedButRevertedByRecipientEventFilter;
        "TransactionResult(bytes)"(returnValue?: null): TransactionResultEventFilter;
        TransactionResult(returnValue?: null): TransactionResultEventFilter;
    };
    estimateGas: {
        addRelayWorkers(newRelayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        deployCall(deployRequest: EnvelopingTypes.DeployRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        disableRelayWorkers(relayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        getRelayInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        getStakeInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        isRelayManagerStaked(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        maxWorkerCount(overrides?: CallOverrides): Promise<BigNumber>;
        minimumEntryDepositValue(overrides?: CallOverrides): Promise<BigNumber>;
        minimumStake(overrides?: CallOverrides): Promise<BigNumber>;
        minimumUnstakeDelay(overrides?: CallOverrides): Promise<BigNumber>;
        penalize(relayWorker: PromiseOrValue<string>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        penalizer(overrides?: CallOverrides): Promise<BigNumber>;
        registerRelayServer(url: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        relayCall(relayRequest: EnvelopingTypes.RelayRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        relayData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        stakeForAddress(relayManager: PromiseOrValue<string>, unstakeDelay: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        stakes(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        unlockStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        versionHub(overrides?: CallOverrides): Promise<BigNumber>;
        withdrawStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<BigNumber>;
        workerCount(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
        workerToManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
    };
    populateTransaction: {
        addRelayWorkers(newRelayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        deployCall(deployRequest: EnvelopingTypes.DeployRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        disableRelayWorkers(relayWorkers: PromiseOrValue<string>[], overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        getRelayInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        getStakeInfo(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        isRelayManagerStaked(relayManager: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        maxWorkerCount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minimumEntryDepositValue(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minimumStake(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        minimumUnstakeDelay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        penalize(relayWorker: PromiseOrValue<string>, beneficiary: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        penalizer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        registerRelayServer(url: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        relayCall(relayRequest: EnvelopingTypes.RelayRequestStruct, signature: PromiseOrValue<BytesLike>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        relayData(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        stakeForAddress(relayManager: PromiseOrValue<string>, unstakeDelay: PromiseOrValue<BigNumberish>, overrides?: PayableOverrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        stakes(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        unlockStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        versionHub(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        withdrawStake(relayManager: PromiseOrValue<string>, overrides?: Overrides & {
            from?: PromiseOrValue<string>;
        }): Promise<PopulatedTransaction>;
        workerCount(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        workerToManager(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
    };
}