/* Autogenerated file. Do not edit manually. */
/* tslint:disable */
/* eslint-disable */
import {
  BaseContract,
  BigNumber,
  BigNumberish,
  BytesLike,
  CallOverrides,
  ContractTransaction,
  Overrides,
  PayableOverrides,
  PopulatedTransaction,
  Signer,
  utils,
} from "ethers";
import { FunctionFragment, Result } from "@ethersproject/abi";
import { Listener, Provider } from "@ethersproject/providers";
import { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";

export type OfferItemStruct = {
  itemType: BigNumberish;
  token: string;
  identifierOrCriteria: BigNumberish;
  startAmount: BigNumberish;
  endAmount: BigNumberish;
};

export type OfferItemStructOutput = [
  number,
  string,
  BigNumber,
  BigNumber,
  BigNumber
] & {
  itemType: number;
  token: string;
  identifierOrCriteria: BigNumber;
  startAmount: BigNumber;
  endAmount: BigNumber;
};

export type ConsiderationItemStruct = {
  itemType: BigNumberish;
  token: string;
  identifierOrCriteria: BigNumberish;
  startAmount: BigNumberish;
  endAmount: BigNumberish;
  recipient: string;
};

export type ConsiderationItemStructOutput = [
  number,
  string,
  BigNumber,
  BigNumber,
  BigNumber,
  string
] & {
  itemType: number;
  token: string;
  identifierOrCriteria: BigNumber;
  startAmount: BigNumber;
  endAmount: BigNumber;
  recipient: string;
};

export type OrderComponentsStruct = {
  offerer: string;
  zone: string;
  offer: OfferItemStruct[];
  consideration: ConsiderationItemStruct[];
  orderType: BigNumberish;
  startTime: BigNumberish;
  endTime: BigNumberish;
  zoneHash: BytesLike;
  salt: BigNumberish;
  conduitKey: BytesLike;
  nonce: BigNumberish;
};

export type OrderComponentsStructOutput = [
  string,
  string,
  OfferItemStructOutput[],
  ConsiderationItemStructOutput[],
  number,
  BigNumber,
  BigNumber,
  string,
  BigNumber,
  string,
  BigNumber
] & {
  offerer: string;
  zone: string;
  offer: OfferItemStructOutput[];
  consideration: ConsiderationItemStructOutput[];
  orderType: number;
  startTime: BigNumber;
  endTime: BigNumber;
  zoneHash: string;
  salt: BigNumber;
  conduitKey: string;
  nonce: BigNumber;
};

export type OrderParametersStruct = {
  offerer: string;
  zone: string;
  offer: OfferItemStruct[];
  consideration: ConsiderationItemStruct[];
  orderType: BigNumberish;
  startTime: BigNumberish;
  endTime: BigNumberish;
  zoneHash: BytesLike;
  salt: BigNumberish;
  conduitKey: BytesLike;
  totalOriginalConsiderationItems: BigNumberish;
};

export type OrderParametersStructOutput = [
  string,
  string,
  OfferItemStructOutput[],
  ConsiderationItemStructOutput[],
  number,
  BigNumber,
  BigNumber,
  string,
  BigNumber,
  string,
  BigNumber
] & {
  offerer: string;
  zone: string;
  offer: OfferItemStructOutput[];
  consideration: ConsiderationItemStructOutput[];
  orderType: number;
  startTime: BigNumber;
  endTime: BigNumber;
  zoneHash: string;
  salt: BigNumber;
  conduitKey: string;
  totalOriginalConsiderationItems: BigNumber;
};

export type AdvancedOrderStruct = {
  parameters: OrderParametersStruct;
  numerator: BigNumberish;
  denominator: BigNumberish;
  signature: BytesLike;
  extraData: BytesLike;
};

export type AdvancedOrderStructOutput = [
  OrderParametersStructOutput,
  BigNumber,
  BigNumber,
  string,
  string
] & {
  parameters: OrderParametersStructOutput;
  numerator: BigNumber;
  denominator: BigNumber;
  signature: string;
  extraData: string;
};

export type CriteriaResolverStruct = {
  orderIndex: BigNumberish;
  side: BigNumberish;
  index: BigNumberish;
  identifier: BigNumberish;
  criteriaProof: BytesLike[];
};

export type CriteriaResolverStructOutput = [
  BigNumber,
  number,
  BigNumber,
  BigNumber,
  string[]
] & {
  orderIndex: BigNumber;
  side: number;
  index: BigNumber;
  identifier: BigNumber;
  criteriaProof: string[];
};

export type FulfillmentComponentStruct = {
  orderIndex: BigNumberish;
  itemIndex: BigNumberish;
}[];

export type FulfillmentComponentStructOutput = ([BigNumber, BigNumber] & {
  orderIndex: BigNumber;
  itemIndex: BigNumber;
})[];

export type ReceivedItemStruct = {
  itemType: BigNumberish;
  token: string;
  identifier: BigNumberish;
  amount: BigNumberish;
  recipient: string;
};

export type ReceivedItemStructOutput = [
  number,
  string,
  BigNumber,
  BigNumber,
  string
] & {
  itemType: number;
  token: string;
  identifier: BigNumber;
  amount: BigNumber;
  recipient: string;
};

export type ExecutionStruct = {
  item: ReceivedItemStruct;
  offerer: string;
  conduitKey: BytesLike;
};

export type ExecutionStructOutput = [
  ReceivedItemStructOutput,
  string,
  string
] & { item: ReceivedItemStructOutput; offerer: string; conduitKey: string };

export type OrderStruct = {
  parameters: OrderParametersStruct;
  signature: BytesLike;
};

export type OrderStructOutput = [OrderParametersStructOutput, string] & {
  parameters: OrderParametersStructOutput;
  signature: string;
};

export type AdditionalRecipientStruct = {
  amount: BigNumberish;
  recipient: string;
};

export type AdditionalRecipientStructOutput = [BigNumber, string] & {
  amount: BigNumber;
  recipient: string;
};

export type BasicOrderParametersStruct = {
  considerationToken: string;
  considerationIdentifier: BigNumberish;
  considerationAmount: BigNumberish;
  offerer: string;
  zone: string;
  offerToken: string;
  offerIdentifier: BigNumberish;
  offerAmount: BigNumberish;
  basicOrderType: BigNumberish;
  startTime: BigNumberish;
  endTime: BigNumberish;
  zoneHash: BytesLike;
  salt: BigNumberish;
  offererConduitKey: BytesLike;
  fulfillerConduitKey: BytesLike;
  totalOriginalAdditionalRecipients: BigNumberish;
  additionalRecipients: AdditionalRecipientStruct[];
  signature: BytesLike;
};

export type BasicOrderParametersStructOutput = [
  string,
  BigNumber,
  BigNumber,
  string,
  string,
  string,
  BigNumber,
  BigNumber,
  number,
  BigNumber,
  BigNumber,
  string,
  BigNumber,
  string,
  string,
  BigNumber,
  AdditionalRecipientStructOutput[],
  string
] & {
  considerationToken: string;
  considerationIdentifier: BigNumber;
  considerationAmount: BigNumber;
  offerer: string;
  zone: string;
  offerToken: string;
  offerIdentifier: BigNumber;
  offerAmount: BigNumber;
  basicOrderType: number;
  startTime: BigNumber;
  endTime: BigNumber;
  zoneHash: string;
  salt: BigNumber;
  offererConduitKey: string;
  fulfillerConduitKey: string;
  totalOriginalAdditionalRecipients: BigNumber;
  additionalRecipients: AdditionalRecipientStructOutput[];
  signature: string;
};

export type FulfillmentStruct = {
  offerComponents: FulfillmentComponentStruct[];
  considerationComponents: FulfillmentComponentStruct[];
};

export type FulfillmentStructOutput = [
  FulfillmentComponentStructOutput[],
  FulfillmentComponentStructOutput[]
] & {
  offerComponents: FulfillmentComponentStructOutput[];
  considerationComponents: FulfillmentComponentStructOutput[];
};

export interface ConsiderationInterfaceInterface extends utils.Interface {
  contractName: "ConsiderationInterface";
  functions: {
    "cancel((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256)[])": FunctionFragment;
    "fulfillAdvancedOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes),(uint256,uint8,uint256,uint256,bytes32[])[],bytes32)": FunctionFragment;
    "fulfillAvailableAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],tuple[][],tuple[][],bytes32,uint256)": FunctionFragment;
    "fulfillAvailableOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],tuple[][],tuple[][],bytes32,uint256)": FunctionFragment;
    "fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": FunctionFragment;
    "fulfillOrder(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes),bytes32)": FunctionFragment;
    "getNonce(address)": FunctionFragment;
    "getOrderHash((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": FunctionFragment;
    "getOrderStatus(bytes32)": FunctionFragment;
    "incrementNonce()": FunctionFragment;
    "information()": FunctionFragment;
    "matchAdvancedOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),uint120,uint120,bytes,bytes)[],(uint256,uint8,uint256,uint256,bytes32[])[],((uint256,uint256)[],(uint256,uint256)[])[])": FunctionFragment;
    "matchOrders(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[],((uint256,uint256)[],(uint256,uint256)[])[])": FunctionFragment;
    "name()": FunctionFragment;
    "validate(((address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256),bytes)[])": FunctionFragment;
  };

  encodeFunctionData(
    functionFragment: "cancel",
    values: [OrderComponentsStruct[]]
  ): string;
  encodeFunctionData(
    functionFragment: "fulfillAdvancedOrder",
    values: [AdvancedOrderStruct, CriteriaResolverStruct[], BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "fulfillAvailableAdvancedOrders",
    values: [
      AdvancedOrderStruct[],
      CriteriaResolverStruct[],
      FulfillmentComponentStruct[],
      FulfillmentComponentStruct[],
      BytesLike,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "fulfillAvailableOrders",
    values: [
      OrderStruct[],
      FulfillmentComponentStruct[],
      FulfillmentComponentStruct[],
      BytesLike,
      BigNumberish
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "fulfillBasicOrder",
    values: [BasicOrderParametersStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "fulfillOrder",
    values: [OrderStruct, BytesLike]
  ): string;
  encodeFunctionData(functionFragment: "getNonce", values: [string]): string;
  encodeFunctionData(
    functionFragment: "getOrderHash",
    values: [OrderComponentsStruct]
  ): string;
  encodeFunctionData(
    functionFragment: "getOrderStatus",
    values: [BytesLike]
  ): string;
  encodeFunctionData(
    functionFragment: "incrementNonce",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "information",
    values?: undefined
  ): string;
  encodeFunctionData(
    functionFragment: "matchAdvancedOrders",
    values: [
      AdvancedOrderStruct[],
      CriteriaResolverStruct[],
      FulfillmentStruct[]
    ]
  ): string;
  encodeFunctionData(
    functionFragment: "matchOrders",
    values: [OrderStruct[], FulfillmentStruct[]]
  ): string;
  encodeFunctionData(functionFragment: "name", values?: undefined): string;
  encodeFunctionData(
    functionFragment: "validate",
    values: [OrderStruct[]]
  ): string;

  decodeFunctionResult(functionFragment: "cancel", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "fulfillAdvancedOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fulfillAvailableAdvancedOrders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fulfillAvailableOrders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fulfillBasicOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "fulfillOrder",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "getNonce", data: BytesLike): Result;
  decodeFunctionResult(
    functionFragment: "getOrderHash",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "getOrderStatus",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "incrementNonce",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "information",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchAdvancedOrders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(
    functionFragment: "matchOrders",
    data: BytesLike
  ): Result;
  decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
  decodeFunctionResult(functionFragment: "validate", data: BytesLike): Result;

  events: {};
}

export interface ConsiderationInterface extends BaseContract {
  contractName: "ConsiderationInterface";
  connect(signerOrProvider: Signer | Provider | string): this;
  attach(addressOrName: string): this;
  deployed(): Promise<this>;

  interface: ConsiderationInterfaceInterface;

  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: {
    cancel(
      orders: OrderComponentsStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fulfillAdvancedOrder(
      advancedOrder: AdvancedOrderStruct,
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fulfillAvailableAdvancedOrders(
      advancedOrders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fulfillAvailableOrders(
      orders: OrderStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fulfillBasicOrder(
      parameters: BasicOrderParametersStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    fulfillOrder(
      order: OrderStruct,
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    getNonce(
      offerer: string,
      overrides?: CallOverrides
    ): Promise<[BigNumber] & { nonce: BigNumber }>;

    getOrderHash(
      order: OrderComponentsStruct,
      overrides?: CallOverrides
    ): Promise<[string] & { orderHash: string }>;

    getOrderStatus(
      orderHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, BigNumber, BigNumber] & {
        isValidated: boolean;
        isCancelled: boolean;
        totalFilled: BigNumber;
        totalSize: BigNumber;
      }
    >;

    incrementNonce(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    information(
      overrides?: CallOverrides
    ): Promise<
      [string, string, string] & {
        version: string;
        domainSeparator: string;
        conduitController: string;
      }
    >;

    matchAdvancedOrders(
      orders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    matchOrders(
      orders: OrderStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;

    name(
      overrides?: CallOverrides
    ): Promise<[string] & { contractName: string }>;

    validate(
      orders: OrderStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<ContractTransaction>;
  };

  cancel(
    orders: OrderComponentsStruct[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fulfillAdvancedOrder(
    advancedOrder: AdvancedOrderStruct,
    criteriaResolvers: CriteriaResolverStruct[],
    fulfillerConduitKey: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fulfillAvailableAdvancedOrders(
    advancedOrders: AdvancedOrderStruct[],
    criteriaResolvers: CriteriaResolverStruct[],
    offerFulfillments: FulfillmentComponentStruct[],
    considerationFulfillments: FulfillmentComponentStruct[],
    fulfillerConduitKey: BytesLike,
    maximumFulfilled: BigNumberish,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fulfillAvailableOrders(
    orders: OrderStruct[],
    offerFulfillments: FulfillmentComponentStruct[],
    considerationFulfillments: FulfillmentComponentStruct[],
    fulfillerConduitKey: BytesLike,
    maximumFulfilled: BigNumberish,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fulfillBasicOrder(
    parameters: BasicOrderParametersStruct,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  fulfillOrder(
    order: OrderStruct,
    fulfillerConduitKey: BytesLike,
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  getNonce(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;

  getOrderHash(
    order: OrderComponentsStruct,
    overrides?: CallOverrides
  ): Promise<string>;

  getOrderStatus(
    orderHash: BytesLike,
    overrides?: CallOverrides
  ): Promise<
    [boolean, boolean, BigNumber, BigNumber] & {
      isValidated: boolean;
      isCancelled: boolean;
      totalFilled: BigNumber;
      totalSize: BigNumber;
    }
  >;

  incrementNonce(
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  information(
    overrides?: CallOverrides
  ): Promise<
    [string, string, string] & {
      version: string;
      domainSeparator: string;
      conduitController: string;
    }
  >;

  matchAdvancedOrders(
    orders: AdvancedOrderStruct[],
    criteriaResolvers: CriteriaResolverStruct[],
    fulfillments: FulfillmentStruct[],
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  matchOrders(
    orders: OrderStruct[],
    fulfillments: FulfillmentStruct[],
    overrides?: PayableOverrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  name(overrides?: CallOverrides): Promise<string>;

  validate(
    orders: OrderStruct[],
    overrides?: Overrides & { from?: string | Promise<string> }
  ): Promise<ContractTransaction>;

  callStatic: {
    cancel(
      orders: OrderComponentsStruct[],
      overrides?: CallOverrides
    ): Promise<boolean>;

    fulfillAdvancedOrder(
      advancedOrder: AdvancedOrderStruct,
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillerConduitKey: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    fulfillAvailableAdvancedOrders(
      advancedOrders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [boolean[], ExecutionStructOutput[]] & {
        availableOrders: boolean[];
        executions: ExecutionStructOutput[];
      }
    >;

    fulfillAvailableOrders(
      orders: OrderStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: CallOverrides
    ): Promise<
      [boolean[], ExecutionStructOutput[]] & {
        availableOrders: boolean[];
        executions: ExecutionStructOutput[];
      }
    >;

    fulfillBasicOrder(
      parameters: BasicOrderParametersStruct,
      overrides?: CallOverrides
    ): Promise<boolean>;

    fulfillOrder(
      order: OrderStruct,
      fulfillerConduitKey: BytesLike,
      overrides?: CallOverrides
    ): Promise<boolean>;

    getNonce(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;

    getOrderHash(
      order: OrderComponentsStruct,
      overrides?: CallOverrides
    ): Promise<string>;

    getOrderStatus(
      orderHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<
      [boolean, boolean, BigNumber, BigNumber] & {
        isValidated: boolean;
        isCancelled: boolean;
        totalFilled: BigNumber;
        totalSize: BigNumber;
      }
    >;

    incrementNonce(overrides?: CallOverrides): Promise<BigNumber>;

    information(
      overrides?: CallOverrides
    ): Promise<
      [string, string, string] & {
        version: string;
        domainSeparator: string;
        conduitController: string;
      }
    >;

    matchAdvancedOrders(
      orders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: CallOverrides
    ): Promise<ExecutionStructOutput[]>;

    matchOrders(
      orders: OrderStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: CallOverrides
    ): Promise<ExecutionStructOutput[]>;

    name(overrides?: CallOverrides): Promise<string>;

    validate(
      orders: OrderStruct[],
      overrides?: CallOverrides
    ): Promise<boolean>;
  };

  filters: {};

  estimateGas: {
    cancel(
      orders: OrderComponentsStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fulfillAdvancedOrder(
      advancedOrder: AdvancedOrderStruct,
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fulfillAvailableAdvancedOrders(
      advancedOrders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fulfillAvailableOrders(
      orders: OrderStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fulfillBasicOrder(
      parameters: BasicOrderParametersStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    fulfillOrder(
      order: OrderStruct,
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    getNonce(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;

    getOrderHash(
      order: OrderComponentsStruct,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    getOrderStatus(
      orderHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<BigNumber>;

    incrementNonce(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    information(overrides?: CallOverrides): Promise<BigNumber>;

    matchAdvancedOrders(
      orders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    matchOrders(
      orders: OrderStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;

    name(overrides?: CallOverrides): Promise<BigNumber>;

    validate(
      orders: OrderStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<BigNumber>;
  };

  populateTransaction: {
    cancel(
      orders: OrderComponentsStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fulfillAdvancedOrder(
      advancedOrder: AdvancedOrderStruct,
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fulfillAvailableAdvancedOrders(
      advancedOrders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fulfillAvailableOrders(
      orders: OrderStruct[],
      offerFulfillments: FulfillmentComponentStruct[],
      considerationFulfillments: FulfillmentComponentStruct[],
      fulfillerConduitKey: BytesLike,
      maximumFulfilled: BigNumberish,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fulfillBasicOrder(
      parameters: BasicOrderParametersStruct,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    fulfillOrder(
      order: OrderStruct,
      fulfillerConduitKey: BytesLike,
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    getNonce(
      offerer: string,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getOrderHash(
      order: OrderComponentsStruct,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    getOrderStatus(
      orderHash: BytesLike,
      overrides?: CallOverrides
    ): Promise<PopulatedTransaction>;

    incrementNonce(
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    information(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    matchAdvancedOrders(
      orders: AdvancedOrderStruct[],
      criteriaResolvers: CriteriaResolverStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    matchOrders(
      orders: OrderStruct[],
      fulfillments: FulfillmentStruct[],
      overrides?: PayableOverrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;

    name(overrides?: CallOverrides): Promise<PopulatedTransaction>;

    validate(
      orders: OrderStruct[],
      overrides?: Overrides & { from?: string | Promise<string> }
    ): Promise<PopulatedTransaction>;
  };
}