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 ISwapERC20Interface extends utils.Interface {
    functions: {
        "authorize(address)": FunctionFragment;
        "authorized(address)": FunctionFragment;
        "calculateProtocolFee(address,uint256)": FunctionFragment;
        "cancel(uint256[])": FunctionFragment;
        "check(address,uint256,uint256,address,address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
        "nonceUsed(address,uint256)": FunctionFragment;
        "revoke()": FunctionFragment;
        "swap(address,uint256,uint256,address,address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
        "swapAnySender(address,uint256,uint256,address,address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
        "swapLight(uint256,uint256,address,address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "authorize" | "authorized" | "calculateProtocolFee" | "cancel" | "check" | "nonceUsed" | "revoke" | "swap" | "swapAnySender" | "swapLight"): FunctionFragment;
    encodeFunctionData(functionFragment: "authorize", values: [string]): string;
    encodeFunctionData(functionFragment: "authorized", values: [string]): string;
    encodeFunctionData(functionFragment: "calculateProtocolFee", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "cancel", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "check", values: [
        string,
        BigNumberish,
        BigNumberish,
        string,
        string,
        BigNumberish,
        string,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike
    ]): string;
    encodeFunctionData(functionFragment: "nonceUsed", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "revoke", values?: undefined): string;
    encodeFunctionData(functionFragment: "swap", values: [
        string,
        BigNumberish,
        BigNumberish,
        string,
        string,
        BigNumberish,
        string,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike
    ]): string;
    encodeFunctionData(functionFragment: "swapAnySender", values: [
        string,
        BigNumberish,
        BigNumberish,
        string,
        string,
        BigNumberish,
        string,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike
    ]): string;
    encodeFunctionData(functionFragment: "swapLight", values: [
        BigNumberish,
        BigNumberish,
        string,
        string,
        BigNumberish,
        string,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike
    ]): string;
    decodeFunctionResult(functionFragment: "authorize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorized", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calculateProtocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "check", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nonceUsed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapAnySender", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapLight", data: BytesLike): Result;
    events: {
        "Authorize(address,address)": EventFragment;
        "Cancel(uint256,address)": EventFragment;
        "Revoke(address,address)": EventFragment;
        "SetBonusMax(uint256)": EventFragment;
        "SetBonusScale(uint256)": EventFragment;
        "SetProtocolFee(uint256)": EventFragment;
        "SetProtocolFeeLight(uint256)": EventFragment;
        "SetProtocolFeeWallet(address)": EventFragment;
        "SetStaking(address)": EventFragment;
        "SwapERC20(uint256,address)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Authorize"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Cancel"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Revoke"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetBonusMax"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetBonusScale"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetProtocolFee"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetProtocolFeeLight"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetProtocolFeeWallet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetStaking"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SwapERC20"): EventFragment;
}
export interface AuthorizeEventObject {
    signer: string;
    signerWallet: string;
}
export type AuthorizeEvent = TypedEvent<[string, string], AuthorizeEventObject>;
export type AuthorizeEventFilter = TypedEventFilter<AuthorizeEvent>;
export interface CancelEventObject {
    nonce: BigNumber;
    signerWallet: string;
}
export type CancelEvent = TypedEvent<[BigNumber, string], CancelEventObject>;
export type CancelEventFilter = TypedEventFilter<CancelEvent>;
export interface RevokeEventObject {
    signer: string;
    signerWallet: string;
}
export type RevokeEvent = TypedEvent<[string, string], RevokeEventObject>;
export type RevokeEventFilter = TypedEventFilter<RevokeEvent>;
export interface SetBonusMaxEventObject {
    bonusMax: BigNumber;
}
export type SetBonusMaxEvent = TypedEvent<[BigNumber], SetBonusMaxEventObject>;
export type SetBonusMaxEventFilter = TypedEventFilter<SetBonusMaxEvent>;
export interface SetBonusScaleEventObject {
    bonusScale: BigNumber;
}
export type SetBonusScaleEvent = TypedEvent<[
    BigNumber
], SetBonusScaleEventObject>;
export type SetBonusScaleEventFilter = TypedEventFilter<SetBonusScaleEvent>;
export interface SetProtocolFeeEventObject {
    protocolFee: BigNumber;
}
export type SetProtocolFeeEvent = TypedEvent<[
    BigNumber
], SetProtocolFeeEventObject>;
export type SetProtocolFeeEventFilter = TypedEventFilter<SetProtocolFeeEvent>;
export interface SetProtocolFeeLightEventObject {
    protocolFeeLight: BigNumber;
}
export type SetProtocolFeeLightEvent = TypedEvent<[
    BigNumber
], SetProtocolFeeLightEventObject>;
export type SetProtocolFeeLightEventFilter = TypedEventFilter<SetProtocolFeeLightEvent>;
export interface SetProtocolFeeWalletEventObject {
    feeWallet: string;
}
export type SetProtocolFeeWalletEvent = TypedEvent<[
    string
], SetProtocolFeeWalletEventObject>;
export type SetProtocolFeeWalletEventFilter = TypedEventFilter<SetProtocolFeeWalletEvent>;
export interface SetStakingEventObject {
    staking: string;
}
export type SetStakingEvent = TypedEvent<[string], SetStakingEventObject>;
export type SetStakingEventFilter = TypedEventFilter<SetStakingEvent>;
export interface SwapERC20EventObject {
    nonce: BigNumber;
    signerWallet: string;
}
export type SwapERC20Event = TypedEvent<[
    BigNumber,
    string
], SwapERC20EventObject>;
export type SwapERC20EventFilter = TypedEventFilter<SwapERC20Event>;
export interface ISwapERC20 extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: ISwapERC20Interface;
    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: {
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<[string]>;
        calculateProtocolFee(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        check(senderWallet: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<[string[]]>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        swap(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        swapAnySender(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        swapLight(nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    authorize(sender: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
    calculateProtocolFee(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    cancel(nonces: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    check(senderWallet: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<string[]>;
    nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
    revoke(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    swap(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    swapAnySender(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    swapLight(nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        authorize(sender: string, overrides?: CallOverrides): Promise<void>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
        calculateProtocolFee(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        cancel(nonces: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        check(senderWallet: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<string[]>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        revoke(overrides?: CallOverrides): Promise<void>;
        swap(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
        swapAnySender(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
        swapLight(nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<void>;
    };
    filters: {
        "Authorize(address,address)"(signer?: string | null, signerWallet?: string | null): AuthorizeEventFilter;
        Authorize(signer?: string | null, signerWallet?: string | null): AuthorizeEventFilter;
        "Cancel(uint256,address)"(nonce?: BigNumberish | null, signerWallet?: string | null): CancelEventFilter;
        Cancel(nonce?: BigNumberish | null, signerWallet?: string | null): CancelEventFilter;
        "Revoke(address,address)"(signer?: string | null, signerWallet?: string | null): RevokeEventFilter;
        Revoke(signer?: string | null, signerWallet?: string | null): RevokeEventFilter;
        "SetBonusMax(uint256)"(bonusMax?: null): SetBonusMaxEventFilter;
        SetBonusMax(bonusMax?: null): SetBonusMaxEventFilter;
        "SetBonusScale(uint256)"(bonusScale?: null): SetBonusScaleEventFilter;
        SetBonusScale(bonusScale?: null): SetBonusScaleEventFilter;
        "SetProtocolFee(uint256)"(protocolFee?: null): SetProtocolFeeEventFilter;
        SetProtocolFee(protocolFee?: null): SetProtocolFeeEventFilter;
        "SetProtocolFeeLight(uint256)"(protocolFeeLight?: null): SetProtocolFeeLightEventFilter;
        SetProtocolFeeLight(protocolFeeLight?: null): SetProtocolFeeLightEventFilter;
        "SetProtocolFeeWallet(address)"(feeWallet?: string | null): SetProtocolFeeWalletEventFilter;
        SetProtocolFeeWallet(feeWallet?: string | null): SetProtocolFeeWalletEventFilter;
        "SetStaking(address)"(staking?: string | null): SetStakingEventFilter;
        SetStaking(staking?: string | null): SetStakingEventFilter;
        "SwapERC20(uint256,address)"(nonce?: BigNumberish | null, signerWallet?: string | null): SwapERC20EventFilter;
        SwapERC20(nonce?: BigNumberish | null, signerWallet?: string | null): SwapERC20EventFilter;
    };
    estimateGas: {
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        calculateProtocolFee(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        check(senderWallet: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        swap(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        swapAnySender(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        swapLight(nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calculateProtocolFee(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        check(senderWallet: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        swap(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        swapAnySender(recipient: string, nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        swapLight(nonce: BigNumberish, expiry: BigNumberish, signerWallet: string, signerToken: string, signerAmount: BigNumberish, senderToken: string, senderAmount: BigNumberish, v: BigNumberish, r: BytesLike, s: BytesLike, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}