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 } from "../common";
export interface SwapERC20Interface extends utils.Interface {
    functions: {
        "DOMAIN_SEPARATOR()": FunctionFragment;
        "FEE_DIVISOR()": FunctionFragment;
        "ORDER_TYPEHASH()": FunctionFragment;
        "authorize(address)": FunctionFragment;
        "authorized(address)": FunctionFragment;
        "bonusMax()": FunctionFragment;
        "bonusScale()": FunctionFragment;
        "calculateBonus(uint256,uint256)": FunctionFragment;
        "calculateProtocolFee(address,uint256)": FunctionFragment;
        "cancel(uint256[])": FunctionFragment;
        "cancelOwnershipHandover()": FunctionFragment;
        "check(address,uint256,uint256,address,address,uint256,address,uint256,uint8,bytes32,bytes32)": FunctionFragment;
        "completeOwnershipHandover(address)": FunctionFragment;
        "eip712Domain()": FunctionFragment;
        "nonceUsed(address,uint256)": FunctionFragment;
        "owner()": FunctionFragment;
        "ownershipHandoverExpiresAt(address)": FunctionFragment;
        "protocolFee()": FunctionFragment;
        "protocolFeeLight()": FunctionFragment;
        "protocolFeeWallet()": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "requestOwnershipHandover()": FunctionFragment;
        "revoke()": FunctionFragment;
        "setBonusMax(uint256)": FunctionFragment;
        "setBonusScale(uint256)": FunctionFragment;
        "setProtocolFee(uint256)": FunctionFragment;
        "setProtocolFeeLight(uint256)": FunctionFragment;
        "setProtocolFeeWallet(address)": FunctionFragment;
        "setStaking(address)": FunctionFragment;
        "stakingToken()": 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;
        "transferOwnership(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "DOMAIN_SEPARATOR" | "FEE_DIVISOR" | "ORDER_TYPEHASH" | "authorize" | "authorized" | "bonusMax" | "bonusScale" | "calculateBonus" | "calculateProtocolFee" | "cancel" | "cancelOwnershipHandover" | "check" | "completeOwnershipHandover" | "eip712Domain" | "nonceUsed" | "owner" | "ownershipHandoverExpiresAt" | "protocolFee" | "protocolFeeLight" | "protocolFeeWallet" | "renounceOwnership" | "requestOwnershipHandover" | "revoke" | "setBonusMax" | "setBonusScale" | "setProtocolFee" | "setProtocolFeeLight" | "setProtocolFeeWallet" | "setStaking" | "stakingToken" | "swap" | "swapAnySender" | "swapLight" | "transferOwnership"): FunctionFragment;
    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string;
    encodeFunctionData(functionFragment: "FEE_DIVISOR", values?: undefined): string;
    encodeFunctionData(functionFragment: "ORDER_TYPEHASH", values?: undefined): string;
    encodeFunctionData(functionFragment: "authorize", values: [string]): string;
    encodeFunctionData(functionFragment: "authorized", values: [string]): string;
    encodeFunctionData(functionFragment: "bonusMax", values?: undefined): string;
    encodeFunctionData(functionFragment: "bonusScale", values?: undefined): string;
    encodeFunctionData(functionFragment: "calculateBonus", values: [BigNumberish, BigNumberish]): string;
    encodeFunctionData(functionFragment: "calculateProtocolFee", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "cancel", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "cancelOwnershipHandover", values?: undefined): string;
    encodeFunctionData(functionFragment: "check", values: [
        string,
        BigNumberish,
        BigNumberish,
        string,
        string,
        BigNumberish,
        string,
        BigNumberish,
        BigNumberish,
        BytesLike,
        BytesLike
    ]): string;
    encodeFunctionData(functionFragment: "completeOwnershipHandover", values: [string]): string;
    encodeFunctionData(functionFragment: "eip712Domain", values?: undefined): string;
    encodeFunctionData(functionFragment: "nonceUsed", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "ownershipHandoverExpiresAt", values: [string]): string;
    encodeFunctionData(functionFragment: "protocolFee", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolFeeLight", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolFeeWallet", values?: undefined): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "requestOwnershipHandover", values?: undefined): string;
    encodeFunctionData(functionFragment: "revoke", values?: undefined): string;
    encodeFunctionData(functionFragment: "setBonusMax", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setBonusScale", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setProtocolFee", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setProtocolFeeLight", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setProtocolFeeWallet", values: [string]): string;
    encodeFunctionData(functionFragment: "setStaking", values: [string]): string;
    encodeFunctionData(functionFragment: "stakingToken", 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;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "FEE_DIVISOR", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ORDER_TYPEHASH", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorized", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bonusMax", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "bonusScale", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calculateBonus", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "calculateProtocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cancelOwnershipHandover", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "check", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "completeOwnershipHandover", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "eip712Domain", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nonceUsed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "ownershipHandoverExpiresAt", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFeeLight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFeeWallet", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requestOwnershipHandover", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setBonusMax", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setBonusScale", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setProtocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setProtocolFeeLight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setProtocolFeeWallet", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setStaking", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "stakingToken", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapAnySender", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swapLight", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    events: {
        "Authorize(address,address)": EventFragment;
        "Cancel(uint256,address)": EventFragment;
        "OwnershipHandoverCanceled(address)": EventFragment;
        "OwnershipHandoverRequested(address)": EventFragment;
        "OwnershipTransferred(address,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: "OwnershipHandoverCanceled"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipHandoverRequested"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): 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 OwnershipHandoverCanceledEventObject {
    pendingOwner: string;
}
export type OwnershipHandoverCanceledEvent = TypedEvent<[
    string
], OwnershipHandoverCanceledEventObject>;
export type OwnershipHandoverCanceledEventFilter = TypedEventFilter<OwnershipHandoverCanceledEvent>;
export interface OwnershipHandoverRequestedEventObject {
    pendingOwner: string;
}
export type OwnershipHandoverRequestedEvent = TypedEvent<[
    string
], OwnershipHandoverRequestedEventObject>;
export type OwnershipHandoverRequestedEventFilter = TypedEventFilter<OwnershipHandoverRequestedEvent>;
export interface OwnershipTransferredEventObject {
    oldOwner: string;
    newOwner: string;
}
export type OwnershipTransferredEvent = TypedEvent<[
    string,
    string
], OwnershipTransferredEventObject>;
export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
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 SwapERC20 extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: SwapERC20Interface;
    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: {
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<[BigNumber]>;
        ORDER_TYPEHASH(overrides?: CallOverrides): Promise<[string]>;
        authorize(signatory: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<[string]>;
        bonusMax(overrides?: CallOverrides): Promise<[BigNumber]>;
        bonusScale(overrides?: CallOverrides): Promise<[BigNumber]>;
        calculateBonus(stakingBalance: BigNumberish, feeAmount: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        calculateProtocolFee(wallet: string, amount: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        cancelOwnershipHandover(overrides?: PayableOverrides & {
            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[]]>;
        completeOwnershipHandover(pendingOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        eip712Domain(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            string,
            BigNumber[]
        ] & {
            fields: string;
            name: string;
            version: string;
            chainId: BigNumber;
            verifyingContract: string;
            salt: string;
            extensions: BigNumber[];
        }>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
        owner(overrides?: CallOverrides): Promise<[string] & {
            result: string;
        }>;
        ownershipHandoverExpiresAt(pendingOwner: string, overrides?: CallOverrides): Promise<[BigNumber] & {
            result: BigNumber;
        }>;
        protocolFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        protocolFeeLight(overrides?: CallOverrides): Promise<[BigNumber]>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<[string]>;
        renounceOwnership(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        requestOwnershipHandover(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setBonusMax(_bonusMax: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setBonusScale(_bonusScale: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setProtocolFeeLight(_protocolFeeLight: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setStaking(_stakingToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        stakingToken(overrides?: CallOverrides): Promise<[string]>;
        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>;
        transferOwnership(newOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
    FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
    ORDER_TYPEHASH(overrides?: CallOverrides): Promise<string>;
    authorize(signatory: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
    bonusMax(overrides?: CallOverrides): Promise<BigNumber>;
    bonusScale(overrides?: CallOverrides): Promise<BigNumber>;
    calculateBonus(stakingBalance: BigNumberish, feeAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    calculateProtocolFee(wallet: string, amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
    cancel(nonces: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    cancelOwnershipHandover(overrides?: PayableOverrides & {
        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[]>;
    completeOwnershipHandover(pendingOwner: string, overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    eip712Domain(overrides?: CallOverrides): Promise<[
        string,
        string,
        string,
        BigNumber,
        string,
        string,
        BigNumber[]
    ] & {
        fields: string;
        name: string;
        version: string;
        chainId: BigNumber;
        verifyingContract: string;
        salt: string;
        extensions: BigNumber[];
    }>;
    nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
    owner(overrides?: CallOverrides): Promise<string>;
    ownershipHandoverExpiresAt(pendingOwner: string, overrides?: CallOverrides): Promise<BigNumber>;
    protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
    protocolFeeLight(overrides?: CallOverrides): Promise<BigNumber>;
    protocolFeeWallet(overrides?: CallOverrides): Promise<string>;
    renounceOwnership(overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    requestOwnershipHandover(overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    revoke(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setBonusMax(_bonusMax: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setBonusScale(_bonusScale: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setProtocolFeeLight(_protocolFeeLight: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setStaking(_stakingToken: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    stakingToken(overrides?: CallOverrides): Promise<string>;
    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>;
    transferOwnership(newOwner: string, overrides?: PayableOverrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
        ORDER_TYPEHASH(overrides?: CallOverrides): Promise<string>;
        authorize(signatory: string, overrides?: CallOverrides): Promise<void>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
        bonusMax(overrides?: CallOverrides): Promise<BigNumber>;
        bonusScale(overrides?: CallOverrides): Promise<BigNumber>;
        calculateBonus(stakingBalance: BigNumberish, feeAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calculateProtocolFee(wallet: string, amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        cancel(nonces: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        cancelOwnershipHandover(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[]>;
        completeOwnershipHandover(pendingOwner: string, overrides?: CallOverrides): Promise<void>;
        eip712Domain(overrides?: CallOverrides): Promise<[
            string,
            string,
            string,
            BigNumber,
            string,
            string,
            BigNumber[]
        ] & {
            fields: string;
            name: string;
            version: string;
            chainId: BigNumber;
            verifyingContract: string;
            salt: string;
            extensions: BigNumber[];
        }>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        owner(overrides?: CallOverrides): Promise<string>;
        ownershipHandoverExpiresAt(pendingOwner: string, overrides?: CallOverrides): Promise<BigNumber>;
        protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeLight(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<string>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        requestOwnershipHandover(overrides?: CallOverrides): Promise<void>;
        revoke(overrides?: CallOverrides): Promise<void>;
        setBonusMax(_bonusMax: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setBonusScale(_bonusScale: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setProtocolFeeLight(_protocolFeeLight: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: CallOverrides): Promise<void>;
        setStaking(_stakingToken: string, overrides?: CallOverrides): Promise<void>;
        stakingToken(overrides?: CallOverrides): Promise<string>;
        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>;
        transferOwnership(newOwner: string, 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;
        "OwnershipHandoverCanceled(address)"(pendingOwner?: string | null): OwnershipHandoverCanceledEventFilter;
        OwnershipHandoverCanceled(pendingOwner?: string | null): OwnershipHandoverCanceledEventFilter;
        "OwnershipHandoverRequested(address)"(pendingOwner?: string | null): OwnershipHandoverRequestedEventFilter;
        OwnershipHandoverRequested(pendingOwner?: string | null): OwnershipHandoverRequestedEventFilter;
        "OwnershipTransferred(address,address)"(oldOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(oldOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "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: {
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<BigNumber>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
        ORDER_TYPEHASH(overrides?: CallOverrides): Promise<BigNumber>;
        authorize(signatory: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        bonusMax(overrides?: CallOverrides): Promise<BigNumber>;
        bonusScale(overrides?: CallOverrides): Promise<BigNumber>;
        calculateBonus(stakingBalance: BigNumberish, feeAmount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        calculateProtocolFee(wallet: string, amount: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        cancelOwnershipHandover(overrides?: PayableOverrides & {
            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>;
        completeOwnershipHandover(pendingOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        eip712Domain(overrides?: CallOverrides): Promise<BigNumber>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        ownershipHandoverExpiresAt(pendingOwner: string, overrides?: CallOverrides): Promise<BigNumber>;
        protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeLight(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        requestOwnershipHandover(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setBonusMax(_bonusMax: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setBonusScale(_bonusScale: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setProtocolFeeLight(_protocolFeeLight: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setStaking(_stakingToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        stakingToken(overrides?: CallOverrides): 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>;
        transferOwnership(newOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ORDER_TYPEHASH(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        authorize(signatory: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bonusMax(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        bonusScale(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calculateBonus(stakingBalance: BigNumberish, feeAmount: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        calculateProtocolFee(wallet: string, amount: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        cancelOwnershipHandover(overrides?: PayableOverrides & {
            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>;
        completeOwnershipHandover(pendingOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        eip712Domain(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        ownershipHandoverExpiresAt(pendingOwner: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFeeLight(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        requestOwnershipHandover(overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setBonusMax(_bonusMax: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setBonusScale(_bonusScale: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setProtocolFeeLight(_protocolFeeLight: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setStaking(_stakingToken: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        stakingToken(overrides?: CallOverrides): 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>;
        transferOwnership(newOwner: string, overrides?: PayableOverrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}