@imtbl/sdk 1.43.3 → 1.43.4

package/dist/orderbook.d-77162c6c.d.ts

@@ -0,0 +1,1257 @@
+import { M as ModuleConfiguration } from './index.d-f0845744.js';
+import { J as JsonRpcProvider } from './json-rpc-provider.d-5c038bd9.js';
+import { P as PopulatedTransaction } from './index.d-f1471830.js';
+import { m as TypedDataDomain, n as TypedDataField } from './index.d-c4a4c17d.js';
+
+interface OrderbookOverrides {
+    jsonRpcProviderUrl?: string;
+    seaportContractAddress?: string;
+    zoneContractAddress?: string;
+    chainName?: string;
+    apiEndpoint?: string;
+}
+interface OrderbookModuleConfiguration {
+    seaportContractAddress: string;
+    zoneContractAddress: string;
+    apiEndpoint: string;
+    chainName: string;
+    provider: JsonRpcProvider;
+}
+
+type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};
+
+interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+declare class CancelablePromise<T> implements Promise<T> {
+    readonly [Symbol.toStringTag]: string;
+    private _isResolved;
+    private _isRejected;
+    private _isCancelled;
+    private readonly _cancelHandlers;
+    private readonly _promise;
+    private _resolve?;
+    private _reject?;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}
+
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string>;
+    USERNAME?: string | Resolver<string>;
+    PASSWORD?: string | Resolver<string>;
+    HEADERS?: Headers | Resolver<Headers>;
+    ENCODE_PATH?: (path: string) => string;
+};
+
+declare abstract class BaseHttpRequest {
+    readonly config: OpenAPIConfig;
+    constructor(config: OpenAPIConfig);
+    abstract request<T>(options: ApiRequestOptions): CancelablePromise<T>;
+}
+
+type CancelOrdersRequestBody = {
+    /**
+     * Address of the user initiating the cancel request
+     */
+    account_address: string;
+    /**
+     * List of order ids proposed for cancellation
+     */
+    orders: Array<string>;
+    /**
+     * Signature generated by the user for the specific cancellation request
+     */
+    signature: string;
+};
+
+type FailedOrderCancellation = {
+    /**
+     * ID of the order which failed to be cancelled
+     */
+    order: string;
+    /**
+     * Reason code indicating why the order failed to be cancelled
+     */
+    reason_code: FailedOrderCancellation.reason_code;
+};
+declare namespace FailedOrderCancellation {
+    /**
+     * Reason code indicating why the order failed to be cancelled
+     */
+    enum reason_code {
+        FILLED = "FILLED"
+    }
+}
+
+type CancelOrdersResultData = {
+    /**
+     * Orders which were successfully cancelled
+     */
+    successful_cancellations: Array<string>;
+    /**
+     * Orders which are marked for cancellation but the cancellation cannot be guaranteed
+     */
+    pending_cancellations: Array<string>;
+    /**
+     * Orders which failed to be cancelled
+     */
+    failed_cancellations: Array<FailedOrderCancellation>;
+};
+
+type CancelOrdersResult = {
+    result: CancelOrdersResultData;
+};
+
+/**
+ * The name of chain
+ */
+type ChainName = string;
+
+type Fee$1 = {
+    /**
+     * Fee payable to recipient upon settlement
+     */
+    amount: string;
+    /**
+     * Fee type
+     */
+    type: Fee$1.type;
+    /**
+     * Wallet address of fee recipient
+     */
+    recipient_address: string;
+};
+declare namespace Fee$1 {
+    /**
+     * Fee type
+     */
+    enum type {
+        ROYALTY = "ROYALTY",
+        MAKER_ECOSYSTEM = "MAKER_ECOSYSTEM",
+        TAKER_ECOSYSTEM = "TAKER_ECOSYSTEM",
+        PROTOCOL = "PROTOCOL"
+    }
+}
+
+type ERC1155Item$1 = {
+    /**
+     * Token type user is offering, which in this case is ERC1155
+     */
+    type: 'ERC1155';
+    /**
+     * Address of ERC1155 token
+     */
+    contract_address: string;
+    /**
+     * ID of ERC1155 token
+     */
+    token_id: string;
+    /**
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    amount: string;
+};
+
+type ERC20Item$1 = {
+    /**
+     * Token type user is offering, which in this case is ERC20
+     */
+    type: 'ERC20';
+    /**
+     * Address of ERC20 token
+     */
+    contract_address: string;
+    /**
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    amount: string;
+};
+
+type ERC721Item$1 = {
+    /**
+     * Token type user is offering, which in this case is ERC721
+     */
+    type: 'ERC721';
+    /**
+     * Address of ERC721 token
+     */
+    contract_address: string;
+    /**
+     * ID of ERC721 token
+     */
+    token_id: string;
+};
+
+type NativeItem$1 = {
+    /**
+     * Token type user is offering, which in this case is the native IMX token
+     */
+    type: 'NATIVE';
+    /**
+     * A string representing the price at which the user is willing to sell the token. This value is provided in the smallest unit of the token (e.g., wei for Ethereum).
+     */
+    amount: string;
+};
+
+type Item = (NativeItem$1 | ERC20Item$1 | ERC721Item$1 | ERC1155Item$1);
+
+type ProtocolData = {
+    /**
+     * Seaport order type. Orders containing ERC721 tokens will need to pass in the order type as FULL_RESTRICTED while orders with ERC1155 tokens will need to pass in the order_type as PARTIAL_RESTRICTED
+     */
+    order_type: ProtocolData.order_type;
+    /**
+     * big.Int or uint256 string for order counter
+     */
+    counter: string;
+    /**
+     * Immutable zone address
+     */
+    zone_address: string;
+    /**
+     * Immutable Seaport contract address
+     */
+    seaport_address: string;
+    /**
+     * Immutable Seaport contract version
+     */
+    seaport_version: string;
+};
+declare namespace ProtocolData {
+    /**
+     * Seaport order type. Orders containing ERC721 tokens will need to pass in the order type as FULL_RESTRICTED while orders with ERC1155 tokens will need to pass in the order_type as PARTIAL_RESTRICTED
+     */
+    enum order_type {
+        FULL_RESTRICTED = "FULL_RESTRICTED",
+        PARTIAL_RESTRICTED = "PARTIAL_RESTRICTED"
+    }
+}
+
+type CreateListingRequestBody = {
+    account_address: string;
+    order_hash: string;
+    /**
+     * Buy item for listing should either be NATIVE or ERC20 item
+     */
+    buy: Array<Item>;
+    /**
+     * Buy fees should only include maker marketplace fees and should be no more than two entries as more entires will incur more gas. It is best practice to have this as few as possible.
+     */
+    fees: Array<Fee$1>;
+    /**
+     * Time after which the Order is considered expired
+     */
+    end_at: string;
+    protocol_data: ProtocolData;
+    /**
+     * A random value added to the create Order request
+     */
+    salt: string;
+    /**
+     * Sell item for listing should be an ERC721 item
+     */
+    sell: Array<Item>;
+    /**
+     * Digital signature generated by the user for the specific Order
+     */
+    signature: string;
+    /**
+     * Time after which Order is considered active
+     */
+    start_at: string;
+};
+
+/**
+ * The chain details
+ */
+type Chain = {
+    /**
+     * The id of chain
+     */
+    id: string;
+    /**
+     * The name of chain
+     */
+    name: string;
+};
+
+/**
+ * The ratio of the order that has been filled, an order that has been fully filled will have the same numerator and denominator values.
+ */
+type FillStatus = {
+    /**
+     * The numerator of the fill status
+     */
+    numerator: string;
+    /**
+     * The denominator of the fill status
+     */
+    denominator: string;
+};
+
+type ActiveOrderStatus = {
+    /**
+     * The order status that indicates an order can be fulfilled.
+     */
+    name: 'ACTIVE';
+};
+
+type CancelledOrderStatus = {
+    /**
+     * The order status indicating a order is has been cancelled or about to be cancelled.
+     */
+    name: 'CANCELLED';
+    /**
+     * Whether the cancellation of the order is pending
+     */
+    pending: boolean;
+    /**
+     * Whether the cancellation was done on-chain or off-chain or as a result of an underfunded account
+     */
+    cancellation_type: CancelledOrderStatus.cancellation_type;
+};
+declare namespace CancelledOrderStatus {
+    /**
+     * Whether the cancellation was done on-chain or off-chain or as a result of an underfunded account
+     */
+    enum cancellation_type {
+        ON_CHAIN = "ON_CHAIN",
+        OFF_CHAIN = "OFF_CHAIN",
+        UNDERFUNDED = "UNDERFUNDED"
+    }
+}
+
+type ExpiredOrderStatus = {
+    /**
+     * A terminal order status indicating that an order cannot be fulfilled due to expiry.
+     */
+    name: 'EXPIRED';
+};
+
+type FilledOrderStatus = {
+    /**
+     * A terminal order status indicating that an order has been fulfilled.
+     */
+    name: 'FILLED';
+};
+
+type InactiveOrderStatus = {
+    /**
+     * The order status that indicates an order cannot be fulfilled.
+     */
+    name: 'INACTIVE';
+    /**
+     * Whether the order offerer has sufficient approvals
+     */
+    sufficient_approvals: boolean;
+    /**
+     * Whether the order offerer still has sufficient balance to complete the order
+     */
+    sufficient_balances: boolean;
+};
+
+type PendingOrderStatus = {
+    /**
+     * The order status that indicates the order is yet to be active due to various reasons.
+     */
+    name: 'PENDING';
+    /**
+     * Whether the order has been evaluated after its creation
+     */
+    evaluated: boolean;
+    /**
+     * Whether the order has reached its specified start time
+     */
+    started: boolean;
+};
+
+/**
+ * The Order status
+ */
+type OrderStatus = (CancelledOrderStatus | PendingOrderStatus | ActiveOrderStatus | InactiveOrderStatus | FilledOrderStatus | ExpiredOrderStatus);
+
+type Order$1 = {
+    account_address: string;
+    buy: Array<Item>;
+    fees: Array<Fee$1>;
+    chain: Chain;
+    /**
+     * Time the Order is created
+     */
+    created_at: string;
+    /**
+     * Time after which the Order is considered expired
+     */
+    end_at: string;
+    /**
+     * Global Order identifier
+     */
+    id: string;
+    order_hash: string;
+    protocol_data: ProtocolData;
+    /**
+     * A random value added to the create Order request
+     */
+    salt: string;
+    sell: Array<Item>;
+    /**
+     * Digital signature generated by the user for the specific Order
+     */
+    signature: string;
+    /**
+     * Time after which Order is considered active
+     */
+    start_at: string;
+    status: OrderStatus;
+    /**
+     * Order type
+     */
+    type: Order$1.type;
+    /**
+     * Time the Order is last updated
+     */
+    updated_at: string;
+    fill_status: FillStatus;
+};
+declare namespace Order$1 {
+    /**
+     * Order type
+     */
+    enum type {
+        LISTING = "LISTING"
+    }
+}
+
+type FulfillableOrder = {
+    extra_data: string;
+    order: Order$1;
+};
+
+type FulfillmentDataRequest = {
+    order_id: string;
+    /**
+     * Address of the intended account fulfilling the order
+     */
+    taker_address: string;
+    fees: Array<Fee$1>;
+};
+
+type ListingResult$1 = {
+    result: Order$1;
+};
+
+/**
+ * Pagination properties
+ */
+type Page$1 = {
+    /**
+     * First item as an encoded string
+     */
+    previous_cursor: string | null;
+    /**
+     * Last item as an encoded string
+     */
+    next_cursor: string | null;
+};
+
+type ListListingsResult$1 = {
+    page: Page$1;
+    result: Array<Order$1>;
+};
+
+/**
+ * The metadata related to the transaction in which the activity occurred
+ */
+type TradeBlockchainMetadata = {
+    /**
+     * The transaction hash of the trade
+     */
+    transaction_hash: string;
+    /**
+     * EVM block number (uint64 as string)
+     */
+    block_number: string;
+    /**
+     * Transaction index in a block (uint32 as string)
+     */
+    transaction_index: string;
+    /**
+     * The log index of the fulfillment event in a block (uint32 as string)
+     */
+    log_index: string;
+};
+
+type Trade$1 = {
+    buy: Array<Item>;
+    buyer_address: string;
+    buyer_fees: Array<Fee$1>;
+    chain: Chain;
+    order_id: string;
+    blockchain_metadata: TradeBlockchainMetadata;
+    /**
+     * Time the on-chain trade event is indexed by the order book system
+     */
+    indexed_at: string;
+    /**
+     * Global Trade identifier
+     */
+    id: string;
+    sell: Array<Item>;
+    seller_address: string;
+    maker_address: string;
+    taker_address: string;
+};
+
+type ListTradeResult = {
+    page: Page$1;
+    result: Array<Trade$1>;
+};
+
+/**
+ * The Order status
+ */
+declare enum OrderStatusName {
+    PENDING = "PENDING",
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE",
+    FILLED = "FILLED",
+    EXPIRED = "EXPIRED",
+    CANCELLED = "CANCELLED"
+}
+
+/**
+ * Encoded page cursor to retrieve previous or next page. Use the value returned in the response.
+ */
+type PageCursor = string;
+
+/**
+ * Maximum number of items to return
+ */
+type PageSize = number;
+
+type TradeResult$1 = {
+    result: Trade$1;
+};
+
+type UnfulfillableOrder$1 = {
+    /**
+     * OrderID for the requested but unfulfillable order
+     */
+    order_id: string;
+    /**
+     * Nullable string containing error reason if the signing is unsuccessful for the order
+     */
+    reason: string;
+};
+
+declare class OrdersService {
+    readonly httpRequest: BaseHttpRequest;
+    constructor(httpRequest: BaseHttpRequest);
+    /**
+     * Cancel one or more orders
+     * Cancel one or more orders
+     * @returns CancelOrdersResult Orders cancellation response.
+     * @throws ApiError
+     */
+    cancelOrders({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CancelOrdersRequestBody;
+    }): CancelablePromise<CancelOrdersResult>;
+    /**
+     * List all listings
+     * List all listings
+     * @returns ListListingsResult OK response.
+     * @throws ApiError
+     */
+    listListings({ chainName, status, sellItemContractAddress, buyItemType, buyItemContractAddress, accountAddress, sellItemMetadataId, sellItemTokenId, fromUpdatedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        /**
+         * Order status to filter by
+         */
+        status?: OrderStatusName;
+        /**
+         * Sell item contract address to filter by
+         */
+        sellItemContractAddress?: string;
+        /**
+         * Buy item type to filter by
+         */
+        buyItemType?: 'NATIVE' | 'ERC20';
+        /**
+         * Buy item contract address to filter by
+         */
+        buyItemContractAddress?: string;
+        /**
+         * The account address of the user who created the listing
+         */
+        accountAddress?: string;
+        /**
+         * The metadata_id of the sell item
+         */
+        sellItemMetadataId?: string;
+        /**
+         * Sell item token identifier to filter by
+         */
+        sellItemTokenId?: string;
+        /**
+         * From updated at including given date
+         */
+        fromUpdatedAt?: string;
+        /**
+         * Maximum number of orders to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Order field to sort by. `buy_item_amount` sorts by per token price, for example if 5 ERC-1155s are on sale for 10eth, it’s sorted as 2eth for `buy_item_amount`.
+         */
+        sortBy?: 'created_at' | 'updated_at' | 'buy_item_amount';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListListingsResult$1>;
+    /**
+     * Create a listing
+     * Create a listing
+     * @returns ListingResult Created response.
+     * @throws ApiError
+     */
+    createListing({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: CreateListingRequestBody;
+    }): CancelablePromise<ListingResult$1>;
+    /**
+     * Get a single listing by ID
+     * Get a single listing by ID
+     * @returns ListingResult OK response.
+     * @throws ApiError
+     */
+    getListing({ chainName, listingId, }: {
+        chainName: ChainName;
+        /**
+         * Global Order identifier
+         */
+        listingId: string;
+    }): CancelablePromise<ListingResult$1>;
+    /**
+     * Retrieve fulfillment data for orders
+     * Retrieve signed fulfillment data based on the list of order IDs and corresponding fees.
+     * @returns any Successful response
+     * @throws ApiError
+     */
+    fulfillmentData({ chainName, requestBody, }: {
+        chainName: ChainName;
+        requestBody: Array<FulfillmentDataRequest>;
+    }): CancelablePromise<{
+        result: {
+            fulfillable_orders: Array<FulfillableOrder>;
+            unfulfillable_orders: Array<UnfulfillableOrder$1>;
+        };
+    }>;
+    /**
+     * List all trades
+     * List all trades
+     * @returns ListTradeResult OK response.
+     * @throws ApiError
+     */
+    listTrades({ chainName, accountAddress, sellItemContractAddress, fromIndexedAt, pageSize, sortBy, sortDirection, pageCursor, }: {
+        chainName: ChainName;
+        accountAddress?: string;
+        sellItemContractAddress?: string;
+        /**
+         * From indexed at including given date
+         */
+        fromIndexedAt?: string;
+        /**
+         * Maximum number of trades to return per page
+         */
+        pageSize?: PageSize;
+        /**
+         * Trade field to sort by
+         */
+        sortBy?: 'indexed_at';
+        /**
+         * Ascending or descending direction for sort
+         */
+        sortDirection?: 'asc' | 'desc';
+        /**
+         * Page cursor to retrieve previous or next page. Use the value returned in the response.
+         */
+        pageCursor?: PageCursor;
+    }): CancelablePromise<ListTradeResult>;
+    /**
+     * Get a single trade by ID
+     * Get a single trade by ID
+     * @returns TradeResult OK response.
+     * @throws ApiError
+     */
+    getTrade({ chainName, tradeId, }: {
+        chainName: ChainName;
+        /**
+         * Global Trade identifier
+         */
+        tradeId: string;
+    }): CancelablePromise<TradeResult$1>;
+}
+
+/**
+ *  Any type that can be used where a numeric value is needed.
+ */
+type Numeric = number | bigint;
+/**
+ *  Any type that can be used where a big number is needed.
+ */
+type BigNumberish = string | Numeric;
+
+declare enum OrderType {
+    FULL_OPEN = 0,// No partial fills, anyone can execute
+    PARTIAL_OPEN = 1,// Partial fills supported, anyone can execute
+    FULL_RESTRICTED = 2,// No partial fills, only offerer or zone can execute
+    PARTIAL_RESTRICTED = 3
+}
+declare enum ItemType {
+    NATIVE = 0,
+    ERC20 = 1,
+    ERC721 = 2,
+    ERC1155 = 3,
+    ERC721_WITH_CRITERIA = 4,
+    ERC1155_WITH_CRITERIA = 5
+}
+
+type OfferItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+};
+type ConsiderationItem = {
+    itemType: ItemType;
+    token: string;
+    identifierOrCriteria: string;
+    startAmount: string;
+    endAmount: string;
+    recipient: string;
+};
+type OrderParameters = {
+    offerer: string;
+    zone: string;
+    orderType: OrderType;
+    startTime: BigNumberish;
+    endTime: BigNumberish;
+    zoneHash: string;
+    salt: string;
+    offer: OfferItem[];
+    consideration: ConsiderationItem[];
+    totalOriginalConsiderationItems: BigNumberish;
+    conduitKey: string;
+};
+type OrderComponents = OrderParameters & {
+    counter: BigNumberish;
+};
+
+interface ERC1155Item {
+    type: 'ERC1155';
+    contractAddress: string;
+    tokenId: string;
+    amount: string;
+}
+interface ERC721Item {
+    type: 'ERC721';
+    contractAddress: string;
+    tokenId: string;
+}
+interface ERC20Item {
+    type: 'ERC20';
+    contractAddress: string;
+    amount: string;
+}
+interface NativeItem {
+    type: 'NATIVE';
+    amount: string;
+}
+interface RoyaltyInfo {
+    recipient: string;
+    amountRequired: string;
+}
+interface PrepareListingParams {
+    makerAddress: string;
+    sell: ERC721Item | ERC1155Item;
+    buy: ERC20Item | NativeItem;
+    orderExpiry?: Date;
+}
+interface PrepareListingResponse {
+    actions: Action[];
+    orderComponents: OrderComponents;
+    orderHash: string;
+}
+interface PrepareBulkListingsParams {
+    makerAddress: string;
+    listingParams: {
+        sell: ERC721Item | ERC1155Item;
+        buy: ERC20Item | NativeItem;
+        makerFees: FeeValue[];
+        orderExpiry?: Date;
+    }[];
+}
+interface PrepareBulkListingsResponse {
+    actions: Action[];
+    completeListings: (signature: string) => Promise<BulkListingsResult>;
+}
+interface PrepareBulkSeaportOrders {
+    actions: Action[];
+    preparedListings: {
+        orderComponents: OrderComponents;
+        orderHash: string;
+    }[];
+}
+interface PrepareCancelOrdersResponse {
+    signableAction: SignableAction;
+}
+interface CreateListingParams {
+    orderComponents: OrderComponents;
+    orderHash: string;
+    orderSignature: string;
+    makerFees: FeeValue[];
+}
+type ListListingsParams = Omit<Parameters<typeof OrdersService.prototype.listListings>[0], 'chainName'>;
+type ListTradesParams = Omit<Parameters<typeof OrdersService.prototype.listTrades>[0], 'chainName'>;
+declare enum FeeType {
+    MAKER_ECOSYSTEM = "MAKER_ECOSYSTEM",
+    TAKER_ECOSYSTEM = "TAKER_ECOSYSTEM",
+    PROTOCOL = "PROTOCOL",
+    ROYALTY = "ROYALTY"
+}
+interface FeeValue {
+    recipientAddress: string;
+    amount: string;
+}
+interface Fee extends FeeValue {
+    type: FeeType;
+}
+declare enum TransactionPurpose {
+    APPROVAL = "APPROVAL",
+    FULFILL_ORDER = "FULFILL_ORDER",
+    CANCEL = "CANCEL"
+}
+declare enum SignablePurpose {
+    CREATE_LISTING = "CREATE_LISTING",
+    OFF_CHAIN_CANCELLATION = "OFF_CHAIN_CANCELLATION"
+}
+declare enum ActionType {
+    TRANSACTION = "TRANSACTION",
+    SIGNABLE = "SIGNABLE"
+}
+type TransactionBuilder = () => Promise<PopulatedTransaction>;
+interface TransactionAction {
+    type: ActionType.TRANSACTION;
+    purpose: TransactionPurpose;
+    buildTransaction: TransactionBuilder;
+}
+interface SignableAction {
+    type: ActionType.SIGNABLE;
+    purpose: SignablePurpose;
+    message: {
+        domain: TypedDataDomain;
+        types: Record<string, TypedDataField[]>;
+        value: Record<string, any>;
+    };
+}
+type Action = TransactionAction | SignableAction;
+interface FulfillmentListing {
+    listingId: string;
+    takerFees: Array<FeeValue>;
+    amountToFill?: string;
+}
+type FulfillBulkOrdersResponse = FulfillBulkOrdersInsufficientBalanceResponse | FulfillBulkOrdersSufficientBalanceResponse;
+interface FulfillBulkOrdersSufficientBalanceResponse {
+    sufficientBalance: true;
+    actions: Action[];
+    expiration: string;
+    fulfillableOrders: Order[];
+    unfulfillableOrders: UnfulfillableOrder[];
+}
+interface FulfillBulkOrdersInsufficientBalanceResponse {
+    sufficientBalance: false;
+    fulfillableOrders: Order[];
+    unfulfillableOrders: UnfulfillableOrder[];
+}
+interface UnfulfillableOrder {
+    orderId: string;
+    reason: string;
+}
+interface FulfillOrderResponse {
+    actions: Action[];
+    /**
+     * User MUST submit the fulfillment transaction before the expiration
+     * Submitting after the expiration will result in a on chain revert
+     */
+    expiration: string;
+    order: Order;
+}
+interface CancelOrdersOnChainResponse {
+    cancellationAction: TransactionAction;
+}
+interface Order {
+    id: string;
+    type: 'LISTING';
+    accountAddress: string;
+    buy: (ERC20Item | NativeItem)[];
+    sell: (ERC721Item | ERC1155Item)[];
+    fees: Fee[];
+    chain: {
+        id: string;
+        name: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+    fillStatus: {
+        numerator: string;
+        denominator: string;
+    };
+    /**
+     * Time after which the Order is considered active
+     */
+    startAt: string;
+    /**
+     * Time after which the Order is expired
+     */
+    endAt: string;
+    orderHash: string;
+    protocolData: {
+        orderType: 'FULL_RESTRICTED' | 'PARTIAL_RESTRICTED';
+        zoneAddress: string;
+        counter: string;
+        seaportAddress: string;
+        seaportVersion: string;
+    };
+    salt: string;
+    signature: string;
+    status: OrderStatus;
+}
+interface ListingResult {
+    result: Order;
+}
+interface BulkListingsResult {
+    result: {
+        success: boolean;
+        orderHash: string;
+        order?: Order;
+    }[];
+}
+interface ListListingsResult {
+    page: Page;
+    result: Order[];
+}
+interface Page {
+    /**
+     * First item as an encoded string
+     */
+    previousCursor: string | null;
+    /**
+     * Last item as an encoded string
+     */
+    nextCursor: string | null;
+}
+interface Trade {
+    id: string;
+    orderId: string;
+    chain: {
+        id: string;
+        name: string;
+    };
+    buy: (ERC20Item | NativeItem)[];
+    sell: (ERC721Item | ERC1155Item)[];
+    buyerFees: Fee[];
+    sellerAddress: string;
+    buyerAddress: string;
+    makerAddress: string;
+    takerAddress: string;
+    /**
+     * Time the on-chain event was indexed by the Immutable order book service
+     */
+    indexedAt: string;
+    blockchainMetadata: {
+        /**
+         * The transaction hash of the trade
+         */
+        transactionHash: string;
+        /**
+         * EVM block number (uint64 as string)
+         */
+        blockNumber: string;
+        /**
+         * Transaction index in a block (uint32 as string)
+         */
+        transactionIndex: string;
+        /**
+         * The log index of the fulfillment event in a block (uint32 as string)
+         */
+        logIndex: string;
+    };
+}
+interface TradeResult {
+    result: Trade;
+}
+interface ListTradesResult {
+    page: Page;
+    result: Trade[];
+}
+
+/**
+ * zkEVM orderbook SDK
+ * @constructor
+ * @param {OrderbookModuleConfiguration} config - Configuration for Immutable services.
+ */
+declare class Orderbook {
+    private apiClient;
+    private seaport;
+    private orderbookConfig;
+    constructor(config: ModuleConfiguration<OrderbookOverrides>);
+    /**
+     * Return the configuration for the orderbook module.
+     * @return {OrderbookModuleConfiguration} The configuration for the orderbook module.
+     */
+    config(): OrderbookModuleConfiguration;
+    /**
+     * Get an order by ID
+     * @param {string} listingId - The listingId to find.
+     * @return {ListingResult} The returned order result.
+     */
+    getListing(listingId: string): Promise<ListingResult>;
+    /**
+     * Get a trade by ID
+     * @param {string} tradeId - The tradeId to find.
+     * @return {TradeResult} The returned order result.
+     */
+    getTrade(tradeId: string): Promise<TradeResult>;
+    /**
+     * List orders. This method is used to get a list of orders filtered by conditions specified
+     * in the params object.
+     * @param {ListListingsParams} listOrderParams - Filtering, ordering and page parameters.
+     * @return {ListListingsResult} The paged orders.
+     */
+    listListings(listOrderParams: ListListingsParams): Promise<ListListingsResult>;
+    /**
+     * List trades. This method is used to get a list of trades filtered by conditions specified
+     * in the params object
+     * @param {ListTradesParams} listTradesParams - Filtering, ordering and page parameters.
+     * @return {ListTradesResult} The paged trades.
+     */
+    listTrades(listTradesParams: ListTradesParams): Promise<ListTradesResult>;
+    /**
+     * Get required transactions and messages for signing to facilitate creating bulk listings.
+     * Once the transactions are submitted and the message signed, call the completeListings method
+     * provided in the return type with the signature. This method supports up to 20 listing creations
+     * at a time. It can also be used for individual listings to simplify integration code paths.
+     * @param {PrepareBulkListingsParams} prepareBulkListingsParams - Details about the listings
+     * to be created.
+     * @return {PrepareBulkListingsResponse} PrepareListingResponse includes
+     * any unsigned approval transactions, the typed bulk order message for signing and
+     * the createListings method that can be called with the signature to create the listings.
+     */
+    prepareBulkListings({ makerAddress, listingParams, }: PrepareBulkListingsParams): Promise<PrepareBulkListingsResponse>;
+    /**
+     * Get required transactions and messages for signing prior to creating a listing
+     * through the createListing method
+     * @param {PrepareListingParams} prepareListingParams - Details about the listing to be created.
+     * @return {PrepareListingResponse} PrepareListingResponse includes
+     * the unsigned approval transaction, the typed order message for signing and
+     * the order components that can be submitted to `createListing` with a signature.
+     */
+    prepareListing({ makerAddress, sell, buy, orderExpiry, }: PrepareListingParams): Promise<PrepareListingResponse>;
+    /**
+     * Create an order
+     * @param {CreateListingParams} createListingParams - create an order with the given params.
+     * @return {ListingResult} The result of the order created in the Immutable services.
+     */
+    createListing(createListingParams: CreateListingParams): Promise<ListingResult>;
+    /**
+     * Get unsigned transactions that can be submitted to fulfil an open order. If the approval
+     * transaction exists it must be signed and submitted to the chain before the fulfilment
+     * transaction can be submitted or it will be reverted.
+     * @param {string} listingId - The listingId to fulfil.
+     * @param {string} takerAddress - The address of the account fulfilling the order.
+     * @param {FeeValue[]} takerFees - Taker ecosystem fees to be paid.
+     * @param {string} amountToFill - Amount of the order to fill, defaults to sell item amount.
+     *                                Only applies to ERC1155 orders
+     * @return {FulfillOrderResponse} Approval and fulfilment transactions.
+     */
+    fulfillOrder(listingId: string, takerAddress: string, takerFees: FeeValue[], amountToFill?: string): Promise<FulfillOrderResponse>;
+    /**
+     * Get unsigned transactions that can be submitted to fulfil multiple open orders. If approval
+     * transactions exist, they must be signed and submitted to the chain before the fulfilment
+     * transaction can be submitted or it will be reverted.
+     * @param {Array<FulfillmentListing>} listings - The details of the listings to fulfil, amounts
+     *                                               to fill and taker ecosystem fees to be paid.
+     * @param {string} takerAddress - The address of the account fulfilling the order.
+     * @return {FulfillBulkOrdersResponse} Approval and fulfilment transactions.
+     */
+    fulfillBulkOrders(listings: Array<FulfillmentListing>, takerAddress: string): Promise<FulfillBulkOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. For the orderbook to authenticate the cancellation, the creator
+     * of the orders must sign an EIP712 message containing the orderIds
+     * @param {string} orderIds - The orderIds to attempt to cancel.
+     * @return {PrepareCancelOrdersResponse} The signable action to cancel the orders.
+     */
+    prepareOrderCancellations(orderIds: string[]): Promise<PrepareCancelOrdersResponse>;
+    /**
+     * Cancelling orders is a gasless alternative to on-chain cancellation exposed with
+     * `cancelOrdersOnChain`. Orders cancelled this way cannot be fulfilled and will be removed
+     * from the orderbook. If there is pending fulfillment data outstanding for the order, its
+     * cancellation will be pending until the fulfillment window has passed.
+     * `prepareOffchainOrderCancellations` can be used to get the signable action that is signed
+     * to get the signature required for this call.
+     * @param {string[]} orderIds - The orderIds to attempt to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @param {string} accountAddress - The address of the account cancelling the orders.
+     * @return {CancelOrdersResult} The result of the off-chain cancellation request
+     */
+    cancelOrders(orderIds: string[], accountAddress: string, signature: string): Promise<CancelOrdersResult>;
+    /**
+     * Get an unsigned order cancellation transaction. Orders can only be cancelled by
+     * the account that created them. All of the orders must be from the same seaport contract.
+     * If trying to cancel orders from multiple seaport contracts, group the orderIds by seaport
+     * contract and call this method for each group.
+     * @param {string[]} orderIds - The orderIds to cancel.
+     * @param {string} accountAddress - The address of the account cancelling the order.
+     * @return {CancelOrdersOnChainResponse} The unsigned cancel order action
+     */
+    cancelOrdersOnChain(orderIds: string[], accountAddress: string): Promise<CancelOrdersOnChainResponse>;
+}
+
+declare const constants: {
+    estimatedFulfillmentGasGwei: number;
+};
+
+type orderbook_d_Action = Action;
+type orderbook_d_ActionType = ActionType;
+declare const orderbook_d_ActionType: typeof ActionType;
+type orderbook_d_BulkListingsResult = BulkListingsResult;
+type orderbook_d_CancelOrdersOnChainResponse = CancelOrdersOnChainResponse;
+type orderbook_d_CreateListingParams = CreateListingParams;
+type orderbook_d_ERC1155Item = ERC1155Item;
+type orderbook_d_ERC20Item = ERC20Item;
+type orderbook_d_ERC721Item = ERC721Item;
+type orderbook_d_Fee = Fee;
+type orderbook_d_FeeType = FeeType;
+declare const orderbook_d_FeeType: typeof FeeType;
+type orderbook_d_FeeValue = FeeValue;
+type orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse = FulfillBulkOrdersInsufficientBalanceResponse;
+type orderbook_d_FulfillBulkOrdersResponse = FulfillBulkOrdersResponse;
+type orderbook_d_FulfillBulkOrdersSufficientBalanceResponse = FulfillBulkOrdersSufficientBalanceResponse;
+type orderbook_d_FulfillOrderResponse = FulfillOrderResponse;
+type orderbook_d_FulfillmentListing = FulfillmentListing;
+type orderbook_d_ListListingsParams = ListListingsParams;
+type orderbook_d_ListListingsResult = ListListingsResult;
+type orderbook_d_ListTradesParams = ListTradesParams;
+type orderbook_d_ListTradesResult = ListTradesResult;
+type orderbook_d_ListingResult = ListingResult;
+type orderbook_d_NativeItem = NativeItem;
+type orderbook_d_Order = Order;
+type orderbook_d_OrderStatusName = OrderStatusName;
+declare const orderbook_d_OrderStatusName: typeof OrderStatusName;
+type orderbook_d_Orderbook = Orderbook;
+declare const orderbook_d_Orderbook: typeof Orderbook;
+type orderbook_d_OrderbookModuleConfiguration = OrderbookModuleConfiguration;
+type orderbook_d_OrderbookOverrides = OrderbookOverrides;
+type orderbook_d_Page = Page;
+type orderbook_d_PrepareBulkListingsParams = PrepareBulkListingsParams;
+type orderbook_d_PrepareBulkListingsResponse = PrepareBulkListingsResponse;
+type orderbook_d_PrepareBulkSeaportOrders = PrepareBulkSeaportOrders;
+type orderbook_d_PrepareCancelOrdersResponse = PrepareCancelOrdersResponse;
+type orderbook_d_PrepareListingParams = PrepareListingParams;
+type orderbook_d_PrepareListingResponse = PrepareListingResponse;
+type orderbook_d_RoyaltyInfo = RoyaltyInfo;
+type orderbook_d_SignableAction = SignableAction;
+type orderbook_d_SignablePurpose = SignablePurpose;
+declare const orderbook_d_SignablePurpose: typeof SignablePurpose;
+type orderbook_d_Trade = Trade;
+type orderbook_d_TradeResult = TradeResult;
+type orderbook_d_TransactionAction = TransactionAction;
+type orderbook_d_TransactionBuilder = TransactionBuilder;
+type orderbook_d_TransactionPurpose = TransactionPurpose;
+declare const orderbook_d_TransactionPurpose: typeof TransactionPurpose;
+type orderbook_d_UnfulfillableOrder = UnfulfillableOrder;
+declare const orderbook_d_constants: typeof constants;
+declare namespace orderbook_d {
+  export {
+    orderbook_d_Action as Action,
+    orderbook_d_ActionType as ActionType,
+    orderbook_d_BulkListingsResult as BulkListingsResult,
+    orderbook_d_CancelOrdersOnChainResponse as CancelOrdersOnChainResponse,
+    orderbook_d_CreateListingParams as CreateListingParams,
+    orderbook_d_ERC1155Item as ERC1155Item,
+    orderbook_d_ERC20Item as ERC20Item,
+    orderbook_d_ERC721Item as ERC721Item,
+    orderbook_d_Fee as Fee,
+    orderbook_d_FeeType as FeeType,
+    orderbook_d_FeeValue as FeeValue,
+    orderbook_d_FulfillBulkOrdersInsufficientBalanceResponse as FulfillBulkOrdersInsufficientBalanceResponse,
+    orderbook_d_FulfillBulkOrdersResponse as FulfillBulkOrdersResponse,
+    orderbook_d_FulfillBulkOrdersSufficientBalanceResponse as FulfillBulkOrdersSufficientBalanceResponse,
+    orderbook_d_FulfillOrderResponse as FulfillOrderResponse,
+    orderbook_d_FulfillmentListing as FulfillmentListing,
+    orderbook_d_ListListingsParams as ListListingsParams,
+    orderbook_d_ListListingsResult as ListListingsResult,
+    orderbook_d_ListTradesParams as ListTradesParams,
+    orderbook_d_ListTradesResult as ListTradesResult,
+    orderbook_d_ListingResult as ListingResult,
+    orderbook_d_NativeItem as NativeItem,
+    orderbook_d_Order as Order,
+    orderbook_d_OrderStatusName as OrderStatusName,
+    orderbook_d_Orderbook as Orderbook,
+    orderbook_d_OrderbookModuleConfiguration as OrderbookModuleConfiguration,
+    orderbook_d_OrderbookOverrides as OrderbookOverrides,
+    orderbook_d_Page as Page,
+    orderbook_d_PrepareBulkListingsParams as PrepareBulkListingsParams,
+    orderbook_d_PrepareBulkListingsResponse as PrepareBulkListingsResponse,
+    orderbook_d_PrepareBulkSeaportOrders as PrepareBulkSeaportOrders,
+    orderbook_d_PrepareCancelOrdersResponse as PrepareCancelOrdersResponse,
+    orderbook_d_PrepareListingParams as PrepareListingParams,
+    orderbook_d_PrepareListingResponse as PrepareListingResponse,
+    orderbook_d_RoyaltyInfo as RoyaltyInfo,
+    orderbook_d_SignableAction as SignableAction,
+    orderbook_d_SignablePurpose as SignablePurpose,
+    orderbook_d_Trade as Trade,
+    orderbook_d_TradeResult as TradeResult,
+    orderbook_d_TransactionAction as TransactionAction,
+    orderbook_d_TransactionBuilder as TransactionBuilder,
+    orderbook_d_TransactionPurpose as TransactionPurpose,
+    orderbook_d_UnfulfillableOrder as UnfulfillableOrder,
+    orderbook_d_constants as constants,
+  };
+}
+
+export { ActionType as A, BulkListingsResult as B, CreateListingParams as C, ListListingsResult as D, ERC1155Item as E, FeeType as F, Page as G, Trade as H, TradeResult as I, ListTradesResult as J, OrderStatusName as K, ListListingsParams as L, NativeItem as N, Orderbook as O, PrepareListingParams as P, RoyaltyInfo as R, SignablePurpose as S, TransactionPurpose as T, UnfulfillableOrder as U, OrderbookModuleConfiguration as a, OrderbookOverrides as b, constants as c, ERC721Item as d, ERC20Item as e, PrepareListingResponse as f, PrepareBulkListingsParams as g, PrepareBulkListingsResponse as h, PrepareBulkSeaportOrders as i, PrepareCancelOrdersResponse as j, ListTradesParams as k, FeeValue as l, Fee as m, TransactionBuilder as n, orderbook_d as o, TransactionAction as p, SignableAction as q, Action as r, FulfillmentListing as s, FulfillBulkOrdersResponse as t, FulfillBulkOrdersSufficientBalanceResponse as u, FulfillBulkOrdersInsufficientBalanceResponse as v, FulfillOrderResponse as w, CancelOrdersOnChainResponse as x, Order as y, ListingResult as z };