@opensea/seaport-js 2.0.7 → 3.0.0

package/lib/typechain-types/seaport_v1_5/contracts/Seaport.d.ts

@@ -1,85 +1,88 @@
-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";
+import type { BaseContract, BigNumberish, BytesLike, FunctionFragment, Result, Interface, EventFragment, AddressLike, ContractRunner, ContractMethod, Listener } from "ethers";
+import type { TypedContractEvent, TypedDeferredTopicFilter, TypedEventLog, TypedLogDescription, TypedListener, TypedContractMethod } from "../../common";
 export type SpentItemStruct = {
     itemType: BigNumberish;
-    token: string;
+    token: AddressLike;
     identifier: BigNumberish;
     amount: BigNumberish;
 };
-export type SpentItemStructOutput = [number, string, BigNumber, BigNumber] & {
-    itemType: number;
+export type SpentItemStructOutput = [
+    itemType: bigint,
+    token: string,
+    identifier: bigint,
+    amount: bigint
+] & {
+    itemType: bigint;
     token: string;
-    identifier: BigNumber;
-    amount: BigNumber;
+    identifier: bigint;
+    amount: bigint;
 };
 export type ReceivedItemStruct = {
     itemType: BigNumberish;
-    token: string;
+    token: AddressLike;
     identifier: BigNumberish;
     amount: BigNumberish;
-    recipient: string;
+    recipient: AddressLike;
 };
 export type ReceivedItemStructOutput = [
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    string
+    itemType: bigint,
+    token: string,
+    identifier: bigint,
+    amount: bigint,
+    recipient: string
 ] & {
-    itemType: number;
+    itemType: bigint;
     token: string;
-    identifier: BigNumber;
-    amount: BigNumber;
+    identifier: bigint;
+    amount: bigint;
     recipient: string;
 };
 export type OfferItemStruct = {
     itemType: BigNumberish;
-    token: string;
+    token: AddressLike;
     identifierOrCriteria: BigNumberish;
     startAmount: BigNumberish;
     endAmount: BigNumberish;
 };
 export type OfferItemStructOutput = [
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber
+    itemType: bigint,
+    token: string,
+    identifierOrCriteria: bigint,
+    startAmount: bigint,
+    endAmount: bigint
 ] & {
-    itemType: number;
+    itemType: bigint;
     token: string;
-    identifierOrCriteria: BigNumber;
-    startAmount: BigNumber;
-    endAmount: BigNumber;
+    identifierOrCriteria: bigint;
+    startAmount: bigint;
+    endAmount: bigint;
 };
 export type ConsiderationItemStruct = {
     itemType: BigNumberish;
-    token: string;
+    token: AddressLike;
     identifierOrCriteria: BigNumberish;
     startAmount: BigNumberish;
     endAmount: BigNumberish;
-    recipient: string;
+    recipient: AddressLike;
 };
 export type ConsiderationItemStructOutput = [
-    number,
-    string,
-    BigNumber,
-    BigNumber,
-    BigNumber,
-    string
+    itemType: bigint,
+    token: string,
+    identifierOrCriteria: bigint,
+    startAmount: bigint,
+    endAmount: bigint,
+    recipient: string
 ] & {
-    itemType: number;
+    itemType: bigint;
     token: string;
-    identifierOrCriteria: BigNumber;
-    startAmount: BigNumber;
-    endAmount: BigNumber;
+    identifierOrCriteria: bigint;
+    startAmount: bigint;
+    endAmount: bigint;
     recipient: string;
 };
 export type OrderParametersStruct = {
-    offerer: string;
-    zone: string;
+    offerer: AddressLike;
+    zone: AddressLike;
     offer: OfferItemStruct[];
     consideration: ConsiderationItemStruct[];
     orderType: BigNumberish;
@@ -91,33 +94,33 @@ export type OrderParametersStruct = {
     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: bigint,
+    startTime: bigint,
+    endTime: bigint,
+    zoneHash: string,
+    salt: bigint,
+    conduitKey: string,
+    totalOriginalConsiderationItems: bigint
 ] & {
     offerer: string;
     zone: string;
     offer: OfferItemStructOutput[];
     consideration: ConsiderationItemStructOutput[];
-    orderType: number;
-    startTime: BigNumber;
-    endTime: BigNumber;
+    orderType: bigint;
+    startTime: bigint;
+    endTime: bigint;
     zoneHash: string;
-    salt: BigNumber;
+    salt: bigint;
     conduitKey: string;
-    totalOriginalConsiderationItems: BigNumber;
+    totalOriginalConsiderationItems: bigint;
 };
 export type OrderComponentsStruct = {
-    offerer: string;
-    zone: string;
+    offerer: AddressLike;
+    zone: AddressLike;
     offer: OfferItemStruct[];
     consideration: ConsiderationItemStruct[];
     orderType: BigNumberish;
@@ -129,29 +132,29 @@ export type OrderComponentsStruct = {
     counter: BigNumberish;
 };
 export type OrderComponentsStructOutput = [
-    string,
-    string,
-    OfferItemStructOutput[],
-    ConsiderationItemStructOutput[],
-    number,
-    BigNumber,
-    BigNumber,
-    string,
-    BigNumber,
-    string,
-    BigNumber
+    offerer: string,
+    zone: string,
+    offer: OfferItemStructOutput[],
+    consideration: ConsiderationItemStructOutput[],
+    orderType: bigint,
+    startTime: bigint,
+    endTime: bigint,
+    zoneHash: string,
+    salt: bigint,
+    conduitKey: string,
+    counter: bigint
 ] & {
     offerer: string;
     zone: string;
     offer: OfferItemStructOutput[];
     consideration: ConsiderationItemStructOutput[];
-    orderType: number;
-    startTime: BigNumber;
-    endTime: BigNumber;
+    orderType: bigint;
+    startTime: bigint;
+    endTime: bigint;
     zoneHash: string;
-    salt: BigNumber;
+    salt: bigint;
     conduitKey: string;
-    counter: BigNumber;
+    counter: bigint;
 };
 export type AdvancedOrderStruct = {
     parameters: OrderParametersStruct;
@@ -161,15 +164,15 @@ export type AdvancedOrderStruct = {
     extraData: BytesLike;
 };
 export type AdvancedOrderStructOutput = [
-    OrderParametersStructOutput,
-    BigNumber,
-    BigNumber,
-    string,
-    string
+    parameters: OrderParametersStructOutput,
+    numerator: bigint,
+    denominator: bigint,
+    signature: string,
+    extraData: string
 ] & {
     parameters: OrderParametersStructOutput;
-    numerator: BigNumber;
-    denominator: BigNumber;
+    numerator: bigint;
+    denominator: bigint;
     signature: string;
     extraData: string;
 };
@@ -181,35 +184,38 @@ export type CriteriaResolverStruct = {
     criteriaProof: BytesLike[];
 };
 export type CriteriaResolverStructOutput = [
-    BigNumber,
-    number,
-    BigNumber,
-    BigNumber,
-    string[]
+    orderIndex: bigint,
+    side: bigint,
+    index: bigint,
+    identifier: bigint,
+    criteriaProof: string[]
 ] & {
-    orderIndex: BigNumber;
-    side: number;
-    index: BigNumber;
-    identifier: BigNumber;
+    orderIndex: bigint;
+    side: bigint;
+    index: bigint;
+    identifier: bigint;
     criteriaProof: string[];
 };
 export type FulfillmentComponentStruct = {
     orderIndex: BigNumberish;
     itemIndex: BigNumberish;
 };
-export type FulfillmentComponentStructOutput = [BigNumber, BigNumber] & {
-    orderIndex: BigNumber;
-    itemIndex: BigNumber;
+export type FulfillmentComponentStructOutput = [
+    orderIndex: bigint,
+    itemIndex: bigint
+] & {
+    orderIndex: bigint;
+    itemIndex: bigint;
 };
 export type ExecutionStruct = {
     item: ReceivedItemStruct;
-    offerer: string;
+    offerer: AddressLike;
     conduitKey: BytesLike;
 };
 export type ExecutionStructOutput = [
-    ReceivedItemStructOutput,
-    string,
-    string
+    item: ReceivedItemStructOutput,
+    offerer: string,
+    conduitKey: string
 ] & {
     item: ReceivedItemStructOutput;
     offerer: string;
@@ -219,25 +225,31 @@ export type OrderStruct = {
     parameters: OrderParametersStruct;
     signature: BytesLike;
 };
-export type OrderStructOutput = [OrderParametersStructOutput, string] & {
+export type OrderStructOutput = [
+    parameters: OrderParametersStructOutput,
+    signature: string
+] & {
     parameters: OrderParametersStructOutput;
     signature: string;
 };
 export type AdditionalRecipientStruct = {
     amount: BigNumberish;
-    recipient: string;
+    recipient: AddressLike;
 };
-export type AdditionalRecipientStructOutput = [BigNumber, string] & {
-    amount: BigNumber;
+export type AdditionalRecipientStructOutput = [
+    amount: bigint,
+    recipient: string
+] & {
+    amount: bigint;
     recipient: string;
 };
 export type BasicOrderParametersStruct = {
-    considerationToken: string;
+    considerationToken: AddressLike;
     considerationIdentifier: BigNumberish;
     considerationAmount: BigNumberish;
-    offerer: string;
-    zone: string;
-    offerToken: string;
+    offerer: AddressLike;
+    zone: AddressLike;
+    offerToken: AddressLike;
     offerIdentifier: BigNumberish;
     offerAmount: BigNumberish;
     basicOrderType: BigNumberish;
@@ -252,41 +264,41 @@ export type BasicOrderParametersStruct = {
     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: bigint,
+    considerationAmount: bigint,
+    offerer: string,
+    zone: string,
+    offerToken: string,
+    offerIdentifier: bigint,
+    offerAmount: bigint,
+    basicOrderType: bigint,
+    startTime: bigint,
+    endTime: bigint,
+    zoneHash: string,
+    salt: bigint,
+    offererConduitKey: string,
+    fulfillerConduitKey: string,
+    totalOriginalAdditionalRecipients: bigint,
+    additionalRecipients: AdditionalRecipientStructOutput[],
+    signature: string
 ] & {
     considerationToken: string;
-    considerationIdentifier: BigNumber;
-    considerationAmount: BigNumber;
+    considerationIdentifier: bigint;
+    considerationAmount: bigint;
     offerer: string;
     zone: string;
     offerToken: string;
-    offerIdentifier: BigNumber;
-    offerAmount: BigNumber;
-    basicOrderType: number;
-    startTime: BigNumber;
-    endTime: BigNumber;
+    offerIdentifier: bigint;
+    offerAmount: bigint;
+    basicOrderType: bigint;
+    startTime: bigint;
+    endTime: bigint;
     zoneHash: string;
-    salt: BigNumber;
+    salt: bigint;
     offererConduitKey: string;
     fulfillerConduitKey: string;
-    totalOriginalAdditionalRecipients: BigNumber;
+    totalOriginalAdditionalRecipients: bigint;
     additionalRecipients: AdditionalRecipientStructOutput[];
     signature: string;
 };
@@ -295,42 +307,29 @@ export type FulfillmentStruct = {
     considerationComponents: FulfillmentComponentStruct[];
 };
 export type FulfillmentStructOutput = [
-    FulfillmentComponentStructOutput[],
-    FulfillmentComponentStructOutput[]
+    offerComponents: FulfillmentComponentStructOutput[],
+    considerationComponents: FulfillmentComponentStructOutput[]
 ] & {
     offerComponents: FulfillmentComponentStructOutput[];
     considerationComponents: FulfillmentComponentStructOutput[];
 };
-export interface SeaportInterface extends utils.Interface {
-    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,address)": 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[])[],(uint256,uint256)[][],(uint256,uint256)[][],bytes32,address,uint256)": FunctionFragment;
-        "fulfillAvailableOrders(((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)[][],bytes32,uint256)": FunctionFragment;
-        "fulfillBasicOrder((address,uint256,uint256,address,address,address,uint256,uint256,uint8,uint256,uint256,bytes32,uint256,bytes32,bytes32,uint256,(uint256,address)[],bytes))": FunctionFragment;
-        "fulfillBasicOrder_efficient_6GL6yc((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;
-        "getContractOffererNonce(address)": FunctionFragment;
-        "getCounter(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;
-        "incrementCounter()": 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)[])[],address)": 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;
-    };
-    getFunction(nameOrSignatureOrTopic: "cancel" | "fulfillAdvancedOrder" | "fulfillAvailableAdvancedOrders" | "fulfillAvailableOrders" | "fulfillBasicOrder" | "fulfillBasicOrder_efficient_6GL6yc" | "fulfillOrder" | "getContractOffererNonce" | "getCounter" | "getOrderHash" | "getOrderStatus" | "incrementCounter" | "information" | "matchAdvancedOrders" | "matchOrders" | "name" | "validate"): FunctionFragment;
+export interface SeaportInterface extends Interface {
+    getFunction(nameOrSignature: "cancel" | "fulfillAdvancedOrder" | "fulfillAvailableAdvancedOrders" | "fulfillAvailableOrders" | "fulfillBasicOrder" | "fulfillBasicOrder_efficient_6GL6yc" | "fulfillOrder" | "getContractOffererNonce" | "getCounter" | "getOrderHash" | "getOrderStatus" | "incrementCounter" | "information" | "matchAdvancedOrders" | "matchOrders" | "name" | "validate"): FunctionFragment;
+    getEvent(nameOrSignatureOrTopic: "CounterIncremented" | "OrderCancelled" | "OrderFulfilled" | "OrderValidated" | "OrdersMatched"): EventFragment;
     encodeFunctionData(functionFragment: "cancel", values: [OrderComponentsStruct[]]): string;
-    encodeFunctionData(functionFragment: "fulfillAdvancedOrder", values: [AdvancedOrderStruct, CriteriaResolverStruct[], BytesLike, string]): string;
+    encodeFunctionData(functionFragment: "fulfillAdvancedOrder", values: [
+        AdvancedOrderStruct,
+        CriteriaResolverStruct[],
+        BytesLike,
+        AddressLike
+    ]): string;
     encodeFunctionData(functionFragment: "fulfillAvailableAdvancedOrders", values: [
         AdvancedOrderStruct[],
         CriteriaResolverStruct[],
         FulfillmentComponentStruct[][],
         FulfillmentComponentStruct[][],
         BytesLike,
-        string,
+        AddressLike,
         BigNumberish
     ]): string;
     encodeFunctionData(functionFragment: "fulfillAvailableOrders", values: [
@@ -343,8 +342,8 @@ export interface SeaportInterface extends utils.Interface {
     encodeFunctionData(functionFragment: "fulfillBasicOrder", values: [BasicOrderParametersStruct]): string;
     encodeFunctionData(functionFragment: "fulfillBasicOrder_efficient_6GL6yc", values: [BasicOrderParametersStruct]): string;
     encodeFunctionData(functionFragment: "fulfillOrder", values: [OrderStruct, BytesLike]): string;
-    encodeFunctionData(functionFragment: "getContractOffererNonce", values: [string]): string;
-    encodeFunctionData(functionFragment: "getCounter", values: [string]): string;
+    encodeFunctionData(functionFragment: "getContractOffererNonce", values: [AddressLike]): string;
+    encodeFunctionData(functionFragment: "getCounter", values: [AddressLike]): string;
     encodeFunctionData(functionFragment: "getOrderHash", values: [OrderComponentsStruct]): string;
     encodeFunctionData(functionFragment: "getOrderStatus", values: [BytesLike]): string;
     encodeFunctionData(functionFragment: "incrementCounter", values?: undefined): string;
@@ -353,7 +352,7 @@ export interface SeaportInterface extends utils.Interface {
         AdvancedOrderStruct[],
         CriteriaResolverStruct[],
         FulfillmentStruct[],
-        string
+        AddressLike
     ]): string;
     encodeFunctionData(functionFragment: "matchOrders", values: [OrderStruct[], FulfillmentStruct[]]): string;
     encodeFunctionData(functionFragment: "name", values?: undefined): string;
@@ -375,132 +374,187 @@ export interface SeaportInterface extends utils.Interface {
     decodeFunctionResult(functionFragment: "matchOrders", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "name", data: BytesLike): Result;
     decodeFunctionResult(functionFragment: "validate", data: BytesLike): Result;
-    events: {
-        "CounterIncremented(uint256,address)": EventFragment;
-        "OrderCancelled(bytes32,address,address)": EventFragment;
-        "OrderFulfilled(bytes32,address,address,address,(uint8,address,uint256,uint256)[],(uint8,address,uint256,uint256,address)[])": EventFragment;
-        "OrderValidated(bytes32,(address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))": EventFragment;
-        "OrdersMatched(bytes32[])": EventFragment;
-    };
-    getEvent(nameOrSignatureOrTopic: "CounterIncremented"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "OrderCancelled"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "OrderFulfilled"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "OrderValidated"): EventFragment;
-    getEvent(nameOrSignatureOrTopic: "OrdersMatched"): EventFragment;
 }
-export interface CounterIncrementedEventObject {
-    newCounter: BigNumber;
-    offerer: string;
+export declare namespace CounterIncrementedEvent {
+    type InputTuple = [newCounter: BigNumberish, offerer: AddressLike];
+    type OutputTuple = [newCounter: bigint, offerer: string];
+    interface OutputObject {
+        newCounter: bigint;
+        offerer: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type CounterIncrementedEvent = TypedEvent<[
-    BigNumber,
-    string
-], CounterIncrementedEventObject>;
-export type CounterIncrementedEventFilter = TypedEventFilter<CounterIncrementedEvent>;
-export interface OrderCancelledEventObject {
-    orderHash: string;
-    offerer: string;
-    zone: string;
+export declare namespace OrderCancelledEvent {
+    type InputTuple = [
+        orderHash: BytesLike,
+        offerer: AddressLike,
+        zone: AddressLike
+    ];
+    type OutputTuple = [orderHash: string, offerer: string, zone: string];
+    interface OutputObject {
+        orderHash: string;
+        offerer: string;
+        zone: string;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type OrderCancelledEvent = TypedEvent<[
-    string,
-    string,
-    string
-], OrderCancelledEventObject>;
-export type OrderCancelledEventFilter = TypedEventFilter<OrderCancelledEvent>;
-export interface OrderFulfilledEventObject {
-    orderHash: string;
-    offerer: string;
-    zone: string;
-    recipient: string;
-    offer: SpentItemStructOutput[];
-    consideration: ReceivedItemStructOutput[];
+export declare namespace OrderFulfilledEvent {
+    type InputTuple = [
+        orderHash: BytesLike,
+        offerer: AddressLike,
+        zone: AddressLike,
+        recipient: AddressLike,
+        offer: SpentItemStruct[],
+        consideration: ReceivedItemStruct[]
+    ];
+    type OutputTuple = [
+        orderHash: string,
+        offerer: string,
+        zone: string,
+        recipient: string,
+        offer: SpentItemStructOutput[],
+        consideration: ReceivedItemStructOutput[]
+    ];
+    interface OutputObject {
+        orderHash: string;
+        offerer: string;
+        zone: string;
+        recipient: string;
+        offer: SpentItemStructOutput[];
+        consideration: ReceivedItemStructOutput[];
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type OrderFulfilledEvent = TypedEvent<[
-    string,
-    string,
-    string,
-    string,
-    SpentItemStructOutput[],
-    ReceivedItemStructOutput[]
-], OrderFulfilledEventObject>;
-export type OrderFulfilledEventFilter = TypedEventFilter<OrderFulfilledEvent>;
-export interface OrderValidatedEventObject {
-    orderHash: string;
-    orderParameters: OrderParametersStructOutput;
+export declare namespace OrderValidatedEvent {
+    type InputTuple = [
+        orderHash: BytesLike,
+        orderParameters: OrderParametersStruct
+    ];
+    type OutputTuple = [
+        orderHash: string,
+        orderParameters: OrderParametersStructOutput
+    ];
+    interface OutputObject {
+        orderHash: string;
+        orderParameters: OrderParametersStructOutput;
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type OrderValidatedEvent = TypedEvent<[
-    string,
-    OrderParametersStructOutput
-], OrderValidatedEventObject>;
-export type OrderValidatedEventFilter = TypedEventFilter<OrderValidatedEvent>;
-export interface OrdersMatchedEventObject {
-    orderHashes: string[];
+export declare namespace OrdersMatchedEvent {
+    type InputTuple = [orderHashes: BytesLike[]];
+    type OutputTuple = [orderHashes: string[]];
+    interface OutputObject {
+        orderHashes: string[];
+    }
+    type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+    type Filter = TypedDeferredTopicFilter<Event>;
+    type Log = TypedEventLog<Event>;
+    type LogDescription = TypedLogDescription<Event>;
 }
-export type OrdersMatchedEvent = TypedEvent<[
-    string[]
-], OrdersMatchedEventObject>;
-export type OrdersMatchedEventFilter = TypedEventFilter<OrdersMatchedEvent>;
 export interface Seaport extends BaseContract {
-    connect(signerOrProvider: Signer | Provider | string): this;
-    attach(addressOrName: string): this;
-    deployed(): Promise<this>;
+    connect(runner?: ContractRunner | null): Seaport;
+    waitForDeployment(): Promise<this>;
     interface: SeaportInterface;
-    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<ContractTransaction>;
-        fulfillAdvancedOrder(arg0: AdvancedOrderStruct, arg1: CriteriaResolverStruct[], fulfillerConduitKey: BytesLike, recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        fulfillAvailableAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentComponentStruct[][], arg3: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, recipient: string, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        fulfillAvailableOrders(arg0: OrderStruct[], arg1: FulfillmentComponentStruct[][], arg2: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        fulfillBasicOrder(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        fulfillBasicOrder_efficient_6GL6yc(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        fulfillOrder(arg0: OrderStruct, fulfillerConduitKey: BytesLike, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        getContractOffererNonce(contractOfferer: string, overrides?: CallOverrides): Promise<[BigNumber] & {
-            nonce: BigNumber;
-        }>;
-        getCounter(offerer: string, overrides?: CallOverrides): Promise<[BigNumber] & {
-            counter: BigNumber;
-        }>;
-        getOrderHash(arg0: OrderComponentsStruct, overrides?: CallOverrides): Promise<[string] & {
-            orderHash: string;
-        }>;
-        getOrderStatus(orderHash: BytesLike, overrides?: CallOverrides): Promise<[
+    queryFilter<TCEvent extends TypedContractEvent>(event: TCEvent, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    queryFilter<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TypedEventLog<TCEvent>>>;
+    on<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    on<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(event: TCEvent, listener: TypedListener<TCEvent>): Promise<this>;
+    once<TCEvent extends TypedContractEvent>(filter: TypedDeferredTopicFilter<TCEvent>, listener: TypedListener<TCEvent>): Promise<this>;
+    listeners<TCEvent extends TypedContractEvent>(event: TCEvent): Promise<Array<TypedListener<TCEvent>>>;
+    listeners(eventName?: string): Promise<Array<Listener>>;
+    removeAllListeners<TCEvent extends TypedContractEvent>(event?: TCEvent): Promise<this>;
+    cancel: TypedContractMethod<[
+        orders: OrderComponentsStruct[]
+    ], [
+        boolean
+    ], "nonpayable">;
+    fulfillAdvancedOrder: TypedContractMethod<[
+        arg0: AdvancedOrderStruct,
+        arg1: CriteriaResolverStruct[],
+        fulfillerConduitKey: BytesLike,
+        recipient: AddressLike
+    ], [
+        boolean
+    ], "payable">;
+    fulfillAvailableAdvancedOrders: TypedContractMethod<[
+        arg0: AdvancedOrderStruct[],
+        arg1: CriteriaResolverStruct[],
+        arg2: FulfillmentComponentStruct[][],
+        arg3: FulfillmentComponentStruct[][],
+        fulfillerConduitKey: BytesLike,
+        recipient: AddressLike,
+        maximumFulfilled: BigNumberish
+    ], [
+        [boolean[], ExecutionStructOutput[]]
+    ], "payable">;
+    fulfillAvailableOrders: TypedContractMethod<[
+        arg0: OrderStruct[],
+        arg1: FulfillmentComponentStruct[][],
+        arg2: FulfillmentComponentStruct[][],
+        fulfillerConduitKey: BytesLike,
+        maximumFulfilled: BigNumberish
+    ], [
+        [boolean[], ExecutionStructOutput[]]
+    ], "payable">;
+    fulfillBasicOrder: TypedContractMethod<[
+        parameters: BasicOrderParametersStruct
+    ], [
+        boolean
+    ], "payable">;
+    fulfillBasicOrder_efficient_6GL6yc: TypedContractMethod<[
+        parameters: BasicOrderParametersStruct
+    ], [
+        boolean
+    ], "payable">;
+    fulfillOrder: TypedContractMethod<[
+        arg0: OrderStruct,
+        fulfillerConduitKey: BytesLike
+    ], [
+        boolean
+    ], "payable">;
+    getContractOffererNonce: TypedContractMethod<[
+        contractOfferer: AddressLike
+    ], [
+        bigint
+    ], "view">;
+    getCounter: TypedContractMethod<[offerer: AddressLike], [bigint], "view">;
+    getOrderHash: TypedContractMethod<[
+        arg0: OrderComponentsStruct
+    ], [
+        string
+    ], "view">;
+    getOrderStatus: TypedContractMethod<[
+        orderHash: BytesLike
+    ], [
+        [
             boolean,
             boolean,
-            BigNumber,
-            BigNumber
+            bigint,
+            bigint
         ] & {
             isValidated: boolean;
             isCancelled: boolean;
-            totalFilled: BigNumber;
-            totalSize: BigNumber;
-        }>;
-        incrementCounter(overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        information(overrides?: CallOverrides): Promise<[
+            totalFilled: bigint;
+            totalSize: bigint;
+        }
+    ], "view">;
+    incrementCounter: TypedContractMethod<[], [bigint], "nonpayable">;
+    information: TypedContractMethod<[
+    ], [
+        [
             string,
             string,
             string
@@ -508,99 +562,96 @@ export interface Seaport extends BaseContract {
             version: string;
             domainSeparator: string;
             conduitController: string;
-        }>;
-        matchAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentStruct[], recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        matchOrders(arg0: OrderStruct[], arg1: FulfillmentStruct[], overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-        name(overrides?: CallOverrides): Promise<[string]>;
-        validate(arg0: OrderStruct[], overrides?: Overrides & {
-            from?: string;
-        }): Promise<ContractTransaction>;
-    };
-    cancel(orders: OrderComponentsStruct[], overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillAdvancedOrder(arg0: AdvancedOrderStruct, arg1: CriteriaResolverStruct[], fulfillerConduitKey: BytesLike, recipient: string, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillAvailableAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentComponentStruct[][], arg3: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, recipient: string, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillAvailableOrders(arg0: OrderStruct[], arg1: FulfillmentComponentStruct[][], arg2: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillBasicOrder(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillBasicOrder_efficient_6GL6yc(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    fulfillOrder(arg0: OrderStruct, fulfillerConduitKey: BytesLike, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    getContractOffererNonce(contractOfferer: string, overrides?: CallOverrides): Promise<BigNumber>;
-    getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-    getOrderHash(arg0: OrderComponentsStruct, overrides?: CallOverrides): Promise<string>;
-    getOrderStatus(orderHash: BytesLike, overrides?: CallOverrides): Promise<[
-        boolean,
-        boolean,
-        BigNumber,
-        BigNumber
-    ] & {
-        isValidated: boolean;
-        isCancelled: boolean;
-        totalFilled: BigNumber;
-        totalSize: BigNumber;
-    }>;
-    incrementCounter(overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    information(overrides?: CallOverrides): Promise<[
-        string,
-        string,
-        string
-    ] & {
-        version: string;
-        domainSeparator: string;
-        conduitController: string;
-    }>;
-    matchAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentStruct[], recipient: string, overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    matchOrders(arg0: OrderStruct[], arg1: FulfillmentStruct[], overrides?: PayableOverrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    name(overrides?: CallOverrides): Promise<string>;
-    validate(arg0: OrderStruct[], overrides?: Overrides & {
-        from?: string;
-    }): Promise<ContractTransaction>;
-    callStatic: {
-        cancel(orders: OrderComponentsStruct[], overrides?: CallOverrides): Promise<boolean>;
-        fulfillAdvancedOrder(arg0: AdvancedOrderStruct, arg1: CriteriaResolverStruct[], fulfillerConduitKey: BytesLike, recipient: string, overrides?: CallOverrides): Promise<boolean>;
-        fulfillAvailableAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentComponentStruct[][], arg3: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, recipient: string, maximumFulfilled: BigNumberish, overrides?: CallOverrides): Promise<[boolean[], ExecutionStructOutput[]]>;
-        fulfillAvailableOrders(arg0: OrderStruct[], arg1: FulfillmentComponentStruct[][], arg2: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, maximumFulfilled: BigNumberish, overrides?: CallOverrides): Promise<[boolean[], ExecutionStructOutput[]]>;
-        fulfillBasicOrder(parameters: BasicOrderParametersStruct, overrides?: CallOverrides): Promise<boolean>;
-        fulfillBasicOrder_efficient_6GL6yc(parameters: BasicOrderParametersStruct, overrides?: CallOverrides): Promise<boolean>;
-        fulfillOrder(arg0: OrderStruct, fulfillerConduitKey: BytesLike, overrides?: CallOverrides): Promise<boolean>;
-        getContractOffererNonce(contractOfferer: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getOrderHash(arg0: OrderComponentsStruct, overrides?: CallOverrides): Promise<string>;
-        getOrderStatus(orderHash: BytesLike, overrides?: CallOverrides): Promise<[
+        }
+    ], "view">;
+    matchAdvancedOrders: TypedContractMethod<[
+        arg0: AdvancedOrderStruct[],
+        arg1: CriteriaResolverStruct[],
+        arg2: FulfillmentStruct[],
+        recipient: AddressLike
+    ], [
+        ExecutionStructOutput[]
+    ], "payable">;
+    matchOrders: TypedContractMethod<[
+        arg0: OrderStruct[],
+        arg1: FulfillmentStruct[]
+    ], [
+        ExecutionStructOutput[]
+    ], "payable">;
+    name: TypedContractMethod<[], [string], "view">;
+    validate: TypedContractMethod<[arg0: OrderStruct[]], [boolean], "nonpayable">;
+    getFunction<T extends ContractMethod = ContractMethod>(key: string | FunctionFragment): T;
+    getFunction(nameOrSignature: "cancel"): TypedContractMethod<[
+        orders: OrderComponentsStruct[]
+    ], [
+        boolean
+    ], "nonpayable">;
+    getFunction(nameOrSignature: "fulfillAdvancedOrder"): TypedContractMethod<[
+        arg0: AdvancedOrderStruct,
+        arg1: CriteriaResolverStruct[],
+        fulfillerConduitKey: BytesLike,
+        recipient: AddressLike
+    ], [
+        boolean
+    ], "payable">;
+    getFunction(nameOrSignature: "fulfillAvailableAdvancedOrders"): TypedContractMethod<[
+        arg0: AdvancedOrderStruct[],
+        arg1: CriteriaResolverStruct[],
+        arg2: FulfillmentComponentStruct[][],
+        arg3: FulfillmentComponentStruct[][],
+        fulfillerConduitKey: BytesLike,
+        recipient: AddressLike,
+        maximumFulfilled: BigNumberish
+    ], [
+        [boolean[], ExecutionStructOutput[]]
+    ], "payable">;
+    getFunction(nameOrSignature: "fulfillAvailableOrders"): TypedContractMethod<[
+        arg0: OrderStruct[],
+        arg1: FulfillmentComponentStruct[][],
+        arg2: FulfillmentComponentStruct[][],
+        fulfillerConduitKey: BytesLike,
+        maximumFulfilled: BigNumberish
+    ], [
+        [boolean[], ExecutionStructOutput[]]
+    ], "payable">;
+    getFunction(nameOrSignature: "fulfillBasicOrder"): TypedContractMethod<[
+        parameters: BasicOrderParametersStruct
+    ], [
+        boolean
+    ], "payable">;
+    getFunction(nameOrSignature: "fulfillBasicOrder_efficient_6GL6yc"): TypedContractMethod<[
+        parameters: BasicOrderParametersStruct
+    ], [
+        boolean
+    ], "payable">;
+    getFunction(nameOrSignature: "fulfillOrder"): TypedContractMethod<[
+        arg0: OrderStruct,
+        fulfillerConduitKey: BytesLike
+    ], [
+        boolean
+    ], "payable">;
+    getFunction(nameOrSignature: "getContractOffererNonce"): TypedContractMethod<[contractOfferer: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getCounter"): TypedContractMethod<[offerer: AddressLike], [bigint], "view">;
+    getFunction(nameOrSignature: "getOrderHash"): TypedContractMethod<[arg0: OrderComponentsStruct], [string], "view">;
+    getFunction(nameOrSignature: "getOrderStatus"): TypedContractMethod<[
+        orderHash: BytesLike
+    ], [
+        [
             boolean,
             boolean,
-            BigNumber,
-            BigNumber
+            bigint,
+            bigint
         ] & {
             isValidated: boolean;
             isCancelled: boolean;
-            totalFilled: BigNumber;
-            totalSize: BigNumber;
-        }>;
-        incrementCounter(overrides?: CallOverrides): Promise<BigNumber>;
-        information(overrides?: CallOverrides): Promise<[
+            totalFilled: bigint;
+            totalSize: bigint;
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "incrementCounter"): TypedContractMethod<[], [bigint], "nonpayable">;
+    getFunction(nameOrSignature: "information"): TypedContractMethod<[
+    ], [
+        [
             string,
             string,
             string
@@ -608,104 +659,39 @@ export interface Seaport extends BaseContract {
             version: string;
             domainSeparator: string;
             conduitController: string;
-        }>;
-        matchAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentStruct[], recipient: string, overrides?: CallOverrides): Promise<ExecutionStructOutput[]>;
-        matchOrders(arg0: OrderStruct[], arg1: FulfillmentStruct[], overrides?: CallOverrides): Promise<ExecutionStructOutput[]>;
-        name(overrides?: CallOverrides): Promise<string>;
-        validate(arg0: OrderStruct[], overrides?: CallOverrides): Promise<boolean>;
-    };
+        }
+    ], "view">;
+    getFunction(nameOrSignature: "matchAdvancedOrders"): TypedContractMethod<[
+        arg0: AdvancedOrderStruct[],
+        arg1: CriteriaResolverStruct[],
+        arg2: FulfillmentStruct[],
+        recipient: AddressLike
+    ], [
+        ExecutionStructOutput[]
+    ], "payable">;
+    getFunction(nameOrSignature: "matchOrders"): TypedContractMethod<[
+        arg0: OrderStruct[],
+        arg1: FulfillmentStruct[]
+    ], [
+        ExecutionStructOutput[]
+    ], "payable">;
+    getFunction(nameOrSignature: "name"): TypedContractMethod<[], [string], "view">;
+    getFunction(nameOrSignature: "validate"): TypedContractMethod<[arg0: OrderStruct[]], [boolean], "nonpayable">;
+    getEvent(key: "CounterIncremented"): TypedContractEvent<CounterIncrementedEvent.InputTuple, CounterIncrementedEvent.OutputTuple, CounterIncrementedEvent.OutputObject>;
+    getEvent(key: "OrderCancelled"): TypedContractEvent<OrderCancelledEvent.InputTuple, OrderCancelledEvent.OutputTuple, OrderCancelledEvent.OutputObject>;
+    getEvent(key: "OrderFulfilled"): TypedContractEvent<OrderFulfilledEvent.InputTuple, OrderFulfilledEvent.OutputTuple, OrderFulfilledEvent.OutputObject>;
+    getEvent(key: "OrderValidated"): TypedContractEvent<OrderValidatedEvent.InputTuple, OrderValidatedEvent.OutputTuple, OrderValidatedEvent.OutputObject>;
+    getEvent(key: "OrdersMatched"): TypedContractEvent<OrdersMatchedEvent.InputTuple, OrdersMatchedEvent.OutputTuple, OrdersMatchedEvent.OutputObject>;
     filters: {
-        "CounterIncremented(uint256,address)"(newCounter?: null, offerer?: string | null): CounterIncrementedEventFilter;
-        CounterIncremented(newCounter?: null, offerer?: string | null): CounterIncrementedEventFilter;
-        "OrderCancelled(bytes32,address,address)"(orderHash?: null, offerer?: string | null, zone?: string | null): OrderCancelledEventFilter;
-        OrderCancelled(orderHash?: null, offerer?: string | null, zone?: string | null): OrderCancelledEventFilter;
-        "OrderFulfilled(bytes32,address,address,address,(uint8,address,uint256,uint256)[],(uint8,address,uint256,uint256,address)[])"(orderHash?: null, offerer?: string | null, zone?: string | null, recipient?: null, offer?: null, consideration?: null): OrderFulfilledEventFilter;
-        OrderFulfilled(orderHash?: null, offerer?: string | null, zone?: string | null, recipient?: null, offer?: null, consideration?: null): OrderFulfilledEventFilter;
-        "OrderValidated(bytes32,(address,address,(uint8,address,uint256,uint256,uint256)[],(uint8,address,uint256,uint256,uint256,address)[],uint8,uint256,uint256,bytes32,uint256,bytes32,uint256))"(orderHash?: null, orderParameters?: null): OrderValidatedEventFilter;
-        OrderValidated(orderHash?: null, orderParameters?: null): OrderValidatedEventFilter;
-        "OrdersMatched(bytes32[])"(orderHashes?: null): OrdersMatchedEventFilter;
-        OrdersMatched(orderHashes?: null): OrdersMatchedEventFilter;
-    };
-    estimateGas: {
-        cancel(orders: OrderComponentsStruct[], overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillAdvancedOrder(arg0: AdvancedOrderStruct, arg1: CriteriaResolverStruct[], fulfillerConduitKey: BytesLike, recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillAvailableAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentComponentStruct[][], arg3: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, recipient: string, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillAvailableOrders(arg0: OrderStruct[], arg1: FulfillmentComponentStruct[][], arg2: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillBasicOrder(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillBasicOrder_efficient_6GL6yc(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        fulfillOrder(arg0: OrderStruct, fulfillerConduitKey: BytesLike, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        getContractOffererNonce(contractOfferer: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getCounter(offerer: string, overrides?: CallOverrides): Promise<BigNumber>;
-        getOrderHash(arg0: OrderComponentsStruct, overrides?: CallOverrides): Promise<BigNumber>;
-        getOrderStatus(orderHash: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
-        incrementCounter(overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        information(overrides?: CallOverrides): Promise<BigNumber>;
-        matchAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentStruct[], recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        matchOrders(arg0: OrderStruct[], arg1: FulfillmentStruct[], overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-        name(overrides?: CallOverrides): Promise<BigNumber>;
-        validate(arg0: OrderStruct[], overrides?: Overrides & {
-            from?: string;
-        }): Promise<BigNumber>;
-    };
-    populateTransaction: {
-        cancel(orders: OrderComponentsStruct[], overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillAdvancedOrder(arg0: AdvancedOrderStruct, arg1: CriteriaResolverStruct[], fulfillerConduitKey: BytesLike, recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillAvailableAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentComponentStruct[][], arg3: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, recipient: string, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillAvailableOrders(arg0: OrderStruct[], arg1: FulfillmentComponentStruct[][], arg2: FulfillmentComponentStruct[][], fulfillerConduitKey: BytesLike, maximumFulfilled: BigNumberish, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillBasicOrder(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillBasicOrder_efficient_6GL6yc(parameters: BasicOrderParametersStruct, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        fulfillOrder(arg0: OrderStruct, fulfillerConduitKey: BytesLike, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        getContractOffererNonce(contractOfferer: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getCounter(offerer: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getOrderHash(arg0: OrderComponentsStruct, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        getOrderStatus(orderHash: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        incrementCounter(overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        information(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        matchAdvancedOrders(arg0: AdvancedOrderStruct[], arg1: CriteriaResolverStruct[], arg2: FulfillmentStruct[], recipient: string, overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        matchOrders(arg0: OrderStruct[], arg1: FulfillmentStruct[], overrides?: PayableOverrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
-        name(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-        validate(arg0: OrderStruct[], overrides?: Overrides & {
-            from?: string;
-        }): Promise<PopulatedTransaction>;
+        "CounterIncremented(uint256,address)": TypedContractEvent<CounterIncrementedEvent.InputTuple, CounterIncrementedEvent.OutputTuple, CounterIncrementedEvent.OutputObject>;
+        CounterIncremented: TypedContractEvent<CounterIncrementedEvent.InputTuple, CounterIncrementedEvent.OutputTuple, CounterIncrementedEvent.OutputObject>;
+        "OrderCancelled(bytes32,address,address)": TypedContractEvent<OrderCancelledEvent.InputTuple, OrderCancelledEvent.OutputTuple, OrderCancelledEvent.OutputObject>;
+        OrderCancelled: TypedContractEvent<OrderCancelledEvent.InputTuple, OrderCancelledEvent.OutputTuple, OrderCancelledEvent.OutputObject>;
+        "OrderFulfilled(bytes32,address,address,address,tuple[],tuple[])": TypedContractEvent<OrderFulfilledEvent.InputTuple, OrderFulfilledEvent.OutputTuple, OrderFulfilledEvent.OutputObject>;
+        OrderFulfilled: TypedContractEvent<OrderFulfilledEvent.InputTuple, OrderFulfilledEvent.OutputTuple, OrderFulfilledEvent.OutputObject>;
+        "OrderValidated(bytes32,tuple)": TypedContractEvent<OrderValidatedEvent.InputTuple, OrderValidatedEvent.OutputTuple, OrderValidatedEvent.OutputObject>;
+        OrderValidated: TypedContractEvent<OrderValidatedEvent.InputTuple, OrderValidatedEvent.OutputTuple, OrderValidatedEvent.OutputObject>;
+        "OrdersMatched(bytes32[])": TypedContractEvent<OrdersMatchedEvent.InputTuple, OrdersMatchedEvent.OutputTuple, OrdersMatchedEvent.OutputObject>;
+        OrdersMatched: TypedContractEvent<OrdersMatchedEvent.InputTuple, OrdersMatchedEvent.OutputTuple, OrdersMatchedEvent.OutputObject>;
     };
 }