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 type PartyStruct = {
    wallet: string;
    token: string;
    kind: BytesLike;
    id: BigNumberish;
    amount: BigNumberish;
};
export type PartyStructOutput = [
    string,
    string,
    string,
    BigNumber,
    BigNumber
] & {
    wallet: string;
    token: string;
    kind: string;
    id: BigNumber;
    amount: BigNumber;
};
export declare namespace ISwap {
    type OrderStruct = {
        nonce: BigNumberish;
        expiry: BigNumberish;
        signer: PartyStruct;
        sender: PartyStruct;
        affiliateWallet: string;
        affiliateAmount: BigNumberish;
        v: BigNumberish;
        r: BytesLike;
        s: BytesLike;
    };
    type OrderStructOutput = [
        BigNumber,
        BigNumber,
        PartyStructOutput,
        PartyStructOutput,
        string,
        BigNumber,
        number,
        string,
        string
    ] & {
        nonce: BigNumber;
        expiry: BigNumber;
        signer: PartyStructOutput;
        sender: PartyStructOutput;
        affiliateWallet: string;
        affiliateAmount: BigNumber;
        v: number;
        r: string;
        s: string;
    };
}
export interface ISwapInterface extends utils.Interface {
    functions: {
        "adapters(bytes4)": FunctionFragment;
        "authorize(address)": FunctionFragment;
        "authorized(address)": FunctionFragment;
        "cancel(uint256[])": FunctionFragment;
        "cancelUpTo(uint256)": FunctionFragment;
        "check(address,(uint256,uint256,(address,address,bytes4,uint256,uint256),(address,address,bytes4,uint256,uint256),address,uint256,uint8,bytes32,bytes32))": FunctionFragment;
        "nonceUsed(address,uint256)": FunctionFragment;
        "revoke()": FunctionFragment;
        "signatoryMinimumNonce(address)": FunctionFragment;
        "swap(address,uint256,(uint256,uint256,(address,address,bytes4,uint256,uint256),(address,address,bytes4,uint256,uint256),address,uint256,uint8,bytes32,bytes32))": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "adapters" | "authorize" | "authorized" | "cancel" | "cancelUpTo" | "check" | "nonceUsed" | "revoke" | "signatoryMinimumNonce" | "swap"): FunctionFragment;
    encodeFunctionData(functionFragment: "adapters", values: [BytesLike]): string;
    encodeFunctionData(functionFragment: "authorize", values: [string]): string;
    encodeFunctionData(functionFragment: "authorized", values: [string]): string;
    encodeFunctionData(functionFragment: "cancel", values: [BigNumberish[]]): string;
    encodeFunctionData(functionFragment: "cancelUpTo", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "check", values: [string, ISwap.OrderStruct]): string;
    encodeFunctionData(functionFragment: "nonceUsed", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "revoke", values?: undefined): string;
    encodeFunctionData(functionFragment: "signatoryMinimumNonce", values: [string]): string;
    encodeFunctionData(functionFragment: "swap", values: [string, BigNumberish, ISwap.OrderStruct]): string;
    decodeFunctionResult(functionFragment: "adapters", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorize", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "authorized", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "cancelUpTo", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "check", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nonceUsed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "signatoryMinimumNonce", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    events: {
        "Authorize(address,address)": EventFragment;
        "Cancel(uint256,address)": EventFragment;
        "CancelUpTo(uint256,address)": EventFragment;
        "Revoke(address,address)": EventFragment;
        "SetProtocolFee(uint256)": EventFragment;
        "SetProtocolFeeWallet(address)": EventFragment;
        "Swap(uint256,address,uint256,uint256,address,address,uint256,uint256,address,address,uint256)": EventFragment;
    };
    getEvent(nameOrSignatureOrTopic: "Authorize"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Cancel"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "CancelUpTo"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Revoke"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetProtocolFee"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "SetProtocolFeeWallet"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "Swap"): 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 CancelUpToEventObject {
    nonce: BigNumber;
    signerWallet: string;
}
export type CancelUpToEvent = TypedEvent<[
    BigNumber,
    string
], CancelUpToEventObject>;
export type CancelUpToEventFilter = TypedEventFilter<CancelUpToEvent>;
export interface RevokeEventObject {
    signer: string;
    signerWallet: string;
}
export type RevokeEvent = TypedEvent<[string, string], RevokeEventObject>;
export type RevokeEventFilter = TypedEventFilter<RevokeEvent>;
export interface SetProtocolFeeEventObject {
    protocolFee: BigNumber;
}
export type SetProtocolFeeEvent = TypedEvent<[
    BigNumber
], SetProtocolFeeEventObject>;
export type SetProtocolFeeEventFilter = TypedEventFilter<SetProtocolFeeEvent>;
export interface SetProtocolFeeWalletEventObject {
    feeWallet: string;
}
export type SetProtocolFeeWalletEvent = TypedEvent<[
    string
], SetProtocolFeeWalletEventObject>;
export type SetProtocolFeeWalletEventFilter = TypedEventFilter<SetProtocolFeeWalletEvent>;
export interface SwapEventObject {
    nonce: BigNumber;
    signerWallet: string;
    signerAmount: BigNumber;
    signerId: BigNumber;
    signerToken: string;
    senderWallet: string;
    senderAmount: BigNumber;
    senderId: BigNumber;
    senderToken: string;
    affiliateWallet: string;
    affiliateAmount: BigNumber;
}
export type SwapEvent = TypedEvent<[
    BigNumber,
    string,
    BigNumber,
    BigNumber,
    string,
    string,
    BigNumber,
    BigNumber,
    string,
    string,
    BigNumber
], SwapEventObject>;
export type SwapEventFilter = TypedEventFilter<SwapEvent>;
export interface ISwap extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: ISwapInterface;
    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: {
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<[string]>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        cancelUpTo(minimumNonce: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        check(arg0: string, arg1: ISwap.OrderStruct, overrides?: CallOverrides): Promise<[string[]]>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<[BigNumber]>;
        swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
    authorize(sender: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
    cancel(nonces: BigNumberish[], overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    cancelUpTo(minimumNonce: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    check(arg0: string, arg1: ISwap.OrderStruct, overrides?: CallOverrides): Promise<string[]>;
    nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
    revoke(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
    swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
        authorize(sender: string, overrides?: CallOverrides): Promise<void>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<string>;
        cancel(nonces: BigNumberish[], overrides?: CallOverrides): Promise<void>;
        cancelUpTo(minimumNonce: BigNumberish, overrides?: CallOverrides): Promise<void>;
        check(arg0: string, arg1: ISwap.OrderStruct, overrides?: CallOverrides): Promise<string[]>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
        revoke(overrides?: CallOverrides): Promise<void>;
        signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, 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;
        "CancelUpTo(uint256,address)"(nonce?: BigNumberish | null, signerWallet?: string | null): CancelUpToEventFilter;
        CancelUpTo(nonce?: BigNumberish | null, signerWallet?: string | null): CancelUpToEventFilter;
        "Revoke(address,address)"(signer?: string | null, signerWallet?: string | null): RevokeEventFilter;
        Revoke(signer?: string | null, signerWallet?: string | null): RevokeEventFilter;
        "SetProtocolFee(uint256)"(protocolFee?: null): SetProtocolFeeEventFilter;
        SetProtocolFee(protocolFee?: null): SetProtocolFeeEventFilter;
        "SetProtocolFeeWallet(address)"(feeWallet?: string | null): SetProtocolFeeWalletEventFilter;
        SetProtocolFeeWallet(feeWallet?: string | null): SetProtocolFeeWalletEventFilter;
        "Swap(uint256,address,uint256,uint256,address,address,uint256,uint256,address,address,uint256)"(nonce?: BigNumberish | null, signerWallet?: string | null, signerAmount?: null, signerId?: null, signerToken?: null, senderWallet?: string | null, senderAmount?: null, senderId?: null, senderToken?: null, affiliateWallet?: null, affiliateAmount?: null): SwapEventFilter;
        Swap(nonce?: BigNumberish | null, signerWallet?: string | null, signerAmount?: null, signerId?: null, signerToken?: null, senderWallet?: string | null, senderAmount?: null, senderId?: null, senderToken?: null, affiliateWallet?: null, affiliateAmount?: null): SwapEventFilter;
    };
    estimateGas: {
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        cancelUpTo(minimumNonce: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        check(arg0: string, arg1: ISwap.OrderStruct, overrides?: CallOverrides): Promise<BigNumber>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        authorize(sender: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        authorized(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        cancel(nonces: BigNumberish[], overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        cancelUpTo(minimumNonce: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        check(arg0: string, arg1: ISwap.OrderStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nonceUsed(arg0: string, arg1: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}