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 SwapInterface extends utils.Interface {
    functions: {
        "DOMAIN_NAME()": FunctionFragment;
        "DOMAIN_SEPARATOR()": FunctionFragment;
        "DOMAIN_VERSION()": FunctionFragment;
        "FEE_DIVISOR()": FunctionFragment;
        "acceptOwnership()": FunctionFragment;
        "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;
        "eip712Domain()": FunctionFragment;
        "nonceUsed(address,uint256)": FunctionFragment;
        "owner()": FunctionFragment;
        "pendingOwner()": FunctionFragment;
        "protocolFee()": FunctionFragment;
        "protocolFeeWallet()": FunctionFragment;
        "renounceOwnership()": FunctionFragment;
        "requiredSenderKind()": FunctionFragment;
        "revoke()": FunctionFragment;
        "setProtocolFee(uint256)": FunctionFragment;
        "setProtocolFeeWallet(address)": 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;
        "transferOwnership(address)": FunctionFragment;
    };
    getFunction(nameOrSignatureOrTopic: "DOMAIN_NAME" | "DOMAIN_SEPARATOR" | "DOMAIN_VERSION" | "FEE_DIVISOR" | "acceptOwnership" | "adapters" | "authorize" | "authorized" | "cancel" | "cancelUpTo" | "check" | "eip712Domain" | "nonceUsed" | "owner" | "pendingOwner" | "protocolFee" | "protocolFeeWallet" | "renounceOwnership" | "requiredSenderKind" | "revoke" | "setProtocolFee" | "setProtocolFeeWallet" | "signatoryMinimumNonce" | "swap" | "transferOwnership"): FunctionFragment;
    encodeFunctionData(functionFragment: "DOMAIN_NAME", values?: undefined): string;
    encodeFunctionData(functionFragment: "DOMAIN_SEPARATOR", values?: undefined): string;
    encodeFunctionData(functionFragment: "DOMAIN_VERSION", values?: undefined): string;
    encodeFunctionData(functionFragment: "FEE_DIVISOR", values?: undefined): string;
    encodeFunctionData(functionFragment: "acceptOwnership", values?: undefined): string;
    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: "eip712Domain", values?: undefined): string;
    encodeFunctionData(functionFragment: "nonceUsed", values: [string, BigNumberish]): string;
    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolFee", values?: undefined): string;
    encodeFunctionData(functionFragment: "protocolFeeWallet", values?: undefined): string;
    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
    encodeFunctionData(functionFragment: "requiredSenderKind", values?: undefined): string;
    encodeFunctionData(functionFragment: "revoke", values?: undefined): string;
    encodeFunctionData(functionFragment: "setProtocolFee", values: [BigNumberish]): string;
    encodeFunctionData(functionFragment: "setProtocolFeeWallet", values: [string]): string;
    encodeFunctionData(functionFragment: "signatoryMinimumNonce", values: [string]): string;
    encodeFunctionData(functionFragment: "swap", values: [string, BigNumberish, ISwap.OrderStruct]): string;
    encodeFunctionData(functionFragment: "transferOwnership", values: [string]): string;
    decodeFunctionResult(functionFragment: "DOMAIN_NAME", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "DOMAIN_SEPARATOR", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "DOMAIN_VERSION", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "FEE_DIVISOR", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "acceptOwnership", data: BytesLike): Result;
    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: "eip712Domain", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "nonceUsed", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "protocolFeeWallet", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "requiredSenderKind", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "revoke", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setProtocolFee", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "setProtocolFeeWallet", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "signatoryMinimumNonce", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
    events: {
        "Authorize(address,address)": EventFragment;
        "Cancel(uint256,address)": EventFragment;
        "CancelUpTo(uint256,address)": EventFragment;
        "EIP712DomainChanged()": EventFragment;
        "OwnershipTransferStarted(address,address)": EventFragment;
        "OwnershipTransferred(address,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: "EIP712DomainChanged"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): 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 EIP712DomainChangedEventObject {
}
export type EIP712DomainChangedEvent = TypedEvent<[
], EIP712DomainChangedEventObject>;
export type EIP712DomainChangedEventFilter = TypedEventFilter<EIP712DomainChangedEvent>;
export interface OwnershipTransferStartedEventObject {
    previousOwner: string;
    newOwner: string;
}
export type OwnershipTransferStartedEvent = TypedEvent<[
    string,
    string
], OwnershipTransferStartedEventObject>;
export type OwnershipTransferStartedEventFilter = TypedEventFilter<OwnershipTransferStartedEvent>;
export interface OwnershipTransferredEventObject {
    previousOwner: 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 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 Swap extends BaseContract {
    connect(signerOrProvider: Signer | Provider | string): this;
    attach(addressOrName: string): this;
    deployed(): Promise<this>;
    interface: SwapInterface;
    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_NAME(overrides?: CallOverrides): Promise<[string]>;
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<[string]>;
        DOMAIN_VERSION(overrides?: CallOverrides): Promise<[string]>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<[BigNumber]>;
        acceptOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<[string]>;
        authorize(signatory: 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(senderWallet: string, order: ISwap.OrderStruct, overrides?: CallOverrides): Promise<[string[]]>;
        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]>;
        pendingOwner(overrides?: CallOverrides): Promise<[string]>;
        protocolFee(overrides?: CallOverrides): Promise<[BigNumber]>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<[string]>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        requiredSenderKind(overrides?: CallOverrides): Promise<[string]>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
        setProtocolFeeWallet(_protocolFeeWallet: string, 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>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<ContractTransaction>;
    };
    DOMAIN_NAME(overrides?: CallOverrides): Promise<string>;
    DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
    DOMAIN_VERSION(overrides?: CallOverrides): Promise<string>;
    FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
    acceptOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
    authorize(signatory: 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(senderWallet: string, order: ISwap.OrderStruct, overrides?: CallOverrides): Promise<string[]>;
    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>;
    pendingOwner(overrides?: CallOverrides): Promise<string>;
    protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
    protocolFeeWallet(overrides?: CallOverrides): Promise<string>;
    renounceOwnership(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    requiredSenderKind(overrides?: CallOverrides): Promise<string>;
    revoke(overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    setProtocolFeeWallet(_protocolFeeWallet: string, 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>;
    transferOwnership(newOwner: string, overrides?: Overrides & {
        from?: string;
    }): Promise<ContractTransaction>;
    callStatic: {
        DOMAIN_NAME(overrides?: CallOverrides): Promise<string>;
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<string>;
        DOMAIN_VERSION(overrides?: CallOverrides): Promise<string>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
        acceptOwnership(overrides?: CallOverrides): Promise<void>;
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<string>;
        authorize(signatory: 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(senderWallet: string, order: ISwap.OrderStruct, overrides?: CallOverrides): Promise<string[]>;
        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>;
        pendingOwner(overrides?: CallOverrides): Promise<string>;
        protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<string>;
        renounceOwnership(overrides?: CallOverrides): Promise<void>;
        requiredSenderKind(overrides?: CallOverrides): Promise<string>;
        revoke(overrides?: CallOverrides): Promise<void>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: CallOverrides): Promise<void>;
        setProtocolFeeWallet(_protocolFeeWallet: string, overrides?: CallOverrides): Promise<void>;
        signatoryMinimumNonce(arg0: string, overrides?: CallOverrides): Promise<BigNumber>;
        swap(recipient: string, maxRoyalty: BigNumberish, order: ISwap.OrderStruct, 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;
        "CancelUpTo(uint256,address)"(nonce?: BigNumberish | null, signerWallet?: string | null): CancelUpToEventFilter;
        CancelUpTo(nonce?: BigNumberish | null, signerWallet?: string | null): CancelUpToEventFilter;
        "EIP712DomainChanged()"(): EIP712DomainChangedEventFilter;
        EIP712DomainChanged(): EIP712DomainChangedEventFilter;
        "OwnershipTransferStarted(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferStartedEventFilter;
        OwnershipTransferStarted(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferStartedEventFilter;
        "OwnershipTransferred(address,address)"(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        OwnershipTransferred(previousOwner?: string | null, newOwner?: string | null): OwnershipTransferredEventFilter;
        "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: {
        DOMAIN_NAME(overrides?: CallOverrides): Promise<BigNumber>;
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<BigNumber>;
        DOMAIN_VERSION(overrides?: CallOverrides): Promise<BigNumber>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<BigNumber>;
        acceptOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
        authorize(signatory: 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(senderWallet: string, order: ISwap.OrderStruct, overrides?: CallOverrides): Promise<BigNumber>;
        eip712Domain(overrides?: CallOverrides): Promise<BigNumber>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
        owner(overrides?: CallOverrides): Promise<BigNumber>;
        pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFee(overrides?: CallOverrides): Promise<BigNumber>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<BigNumber>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        requiredSenderKind(overrides?: CallOverrides): Promise<BigNumber>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
        setProtocolFeeWallet(_protocolFeeWallet: string, 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>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<BigNumber>;
    };
    populateTransaction: {
        DOMAIN_NAME(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        DOMAIN_SEPARATOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        DOMAIN_VERSION(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        FEE_DIVISOR(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        acceptOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        adapters(arg0: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        authorize(signatory: 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(senderWallet: string, order: ISwap.OrderStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        eip712Domain(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        nonceUsed(signer: string, nonce: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFee(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        protocolFeeWallet(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        renounceOwnership(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        requiredSenderKind(overrides?: CallOverrides): Promise<PopulatedTransaction>;
        revoke(overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setProtocolFee(_protocolFee: BigNumberish, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
        setProtocolFeeWallet(_protocolFeeWallet: string, 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>;
        transferOwnership(newOwner: string, overrides?: Overrides & {
            from?: string;
        }): Promise<PopulatedTransaction>;
    };
}