@0xsequence/marketplace-sdk 0.1.0 → 0.3.0

package/dist/react/hooks/index.d.ts

@@ -1,14 +1,14 @@
 import * as _tanstack_react_query from '@tanstack/react-query';
 import * as _0xsequence_indexer from '@0xsequence/indexer';
-import { Page, SortOrder } from '@0xsequence/indexer';
+import { SortOrder, Page } from '@0xsequence/indexer';
 import * as _0xsequence_network from '@0xsequence/network';
-import { Q as QueryArgSchema, c as ChainId } from '../../types-BzZVURNL.js';
-import { S as SdkConfig } from '../../sdk-config-xWkdBdrL.js';
 import { Hex, Address } from 'viem';
 import { z } from 'zod';
-import { P as PropertyType, M as MarketplaceKind, b as OrderSide, w as Currency, o as CollectibleOrder, aC as GetCollectibleHighestOfferReturn, i as Page$1, aW as ListCollectiblesReturn, S as SortOrder$1, aK as ListCollectibleOffersReturn, aE as GetCollectibleLowestListingReturn, z as Step, D as CreateReq, aP as GenerateListingTransactionArgs, aR as GenerateOfferTransactionArgs, C as ContractType } from '../../marketplace.gen-Ceofb9Cs.js';
+import { Q as QueryArgSchema, c as ChainId } from '../../types-QqXjNuUP.js';
+import { S as SdkConfig } from '../../sdk-config-xWkdBdrL.js';
+import { P as PropertyType, M as MarketplaceKind, b as OrderSide, w as Currency, o as CollectibleOrder, aC as GetCollectibleHighestOfferReturn, S as SortOrder$1, i as Page$1, aY as ListCollectiblesReturn, aK as ListCollectibleOffersReturn, aI as ListCollectibleListingsReturn, aE as GetCollectibleLowestListingReturn, z as Step, D as CreateReq, aP as GenerateListingTransactionArgs, aR as GenerateOfferTransactionArgs, aN as GenerateSellTransactionArgs, g as StepType, E as ExecuteType, C as ContractType, be as CheckoutOptionsMarketplaceReturn } from '../../marketplace.gen-BLP7822q.js';
 import * as _0xsequence_metadata from '@0xsequence/metadata';
-import { c as getMarketplaceClient, S as SequenceMarketplace } from '../../services-BIwQ1C1c.js';
+import { c as getMarketplaceClient } from '../../services-C9-lvWcC.js';
 import { M as MarketplaceConfig } from '../../marketplace-config-Bbxl-uKX.js';
 
 declare const fetchBalanceOfCollectibleSchema: z.ZodObject<{
@@ -29,13 +29,13 @@ declare const fetchBalanceOfCollectibleSchema: z.ZodObject<{
 }>;
 type FetchBalanceOfCollectibleArgs = z.input<typeof fetchBalanceOfCollectibleSchema>;
 interface BalanceOfCollectibleOptions extends Omit<FetchBalanceOfCollectibleArgs, 'userAddress'> {
-    userAddress?: Hex;
+    userAddress: Hex | undefined;
     query?: z.infer<typeof QueryArgSchema>;
 }
-declare const balanceOfCollectibleOptions: (args: BalanceOfCollectibleOptions, config: SdkConfig) => _tanstack_react_query.UseQueryOptions<_0xsequence_indexer.TokenBalance, Error, _0xsequence_indexer.TokenBalance, ("collectable" | "details" | "userBalances" | SdkConfig | BalanceOfCollectibleOptions)[]> & {
+declare const balanceOfCollectibleOptions: (args: BalanceOfCollectibleOptions, config: SdkConfig) => _tanstack_react_query.UseQueryOptions<_0xsequence_indexer.TokenBalance, Error, _0xsequence_indexer.TokenBalance, ("collectable" | "details" | "userBalances" | BalanceOfCollectibleOptions)[]> & {
     initialData?: _0xsequence_indexer.TokenBalance | _tanstack_react_query.InitialDataFunction<_0xsequence_indexer.TokenBalance> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "userBalances" | SdkConfig | BalanceOfCollectibleOptions)[], _0xsequence_indexer.TokenBalance>;
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "details" | "userBalances" | BalanceOfCollectibleOptions)[], _0xsequence_indexer.TokenBalance>;
 };
 declare const useBalanceOfCollectible: (args: BalanceOfCollectibleOptions) => _tanstack_react_query.UseQueryResult<_0xsequence_indexer.TokenBalance, Error>;
 
@@ -434,6 +434,38 @@ declare const currenciesOptions: (args: UseCurrenciesArgs, config: SdkConfig) =>
 };
 declare const useCurrencies: (args: UseCurrenciesArgs) => _tanstack_react_query.UseQueryResult<Currency[], Error>;
 
+declare const UseCurrencyArgsSchema: z.ZodObject<{
+    chainId: z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, string, string | number>;
+    currencyAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    currencyAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
+    currencyAddress: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseCurrencyArgs = z.input<typeof UseCurrencyArgsSchema>;
+type UseCurrencyReturn = Currency | undefined;
+declare const currencyOptions: (args: UseCurrencyArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<Currency | undefined, Error, Currency | undefined, (string | number)[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<Currency | undefined, (string | number)[], never> | undefined;
+} & {
+    queryKey: _tanstack_react_query.DataTag<(string | number)[], Currency | undefined>;
+};
+declare const useCurrency: (args: UseCurrencyArgs) => _tanstack_react_query.UseQueryResult<Currency | undefined, Error>;
+
 declare const UseFiltersSchema: z.ZodObject<{
     chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
     collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
@@ -770,7 +802,7 @@ declare const useListBalancesArgsSchema: z.ZodObject<{
 }>;
 type UseFetchTokenBalancesReturn = Awaited<ReturnType<typeof fetchBalances>>;
 type UseListBalancesArgs = z.input<typeof useListBalancesArgsSchema>;
-declare const fetchBalances: (args: UseListBalancesArgs, page: Page, config: SdkConfig) => Promise<_0xsequence_indexer.GetTokenBalancesReturn>;
+declare const fetchBalances: (args: UseListBalancesArgs, config: SdkConfig, page: Page) => Promise<_0xsequence_indexer.GetTokenBalancesReturn>;
 declare const listBalancesOptions: (args: UseListBalancesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<_0xsequence_indexer.GetTokenBalancesReturn, Error, _tanstack_react_query.InfiniteData<_0xsequence_indexer.GetTokenBalancesReturn, unknown>, _0xsequence_indexer.GetTokenBalancesReturn, ("balances" | "tokenBalances" | SdkConfig | {
     chainId: string | number;
     page?: {
@@ -1028,8 +1060,8 @@ declare const UseListCollectiblesArgsSchema: z.ZodObject<z.objectUtil.extendShap
 }>;
 type UseListCollectiblesArgs = z.infer<typeof UseListCollectiblesArgsSchema>;
 type UseListCollectiblesReturn = Awaited<ReturnType<typeof fetchCollectibles>>;
-declare const fetchCollectibles: (args: UseListCollectiblesArgs, page: Page$1, marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>) => Promise<ListCollectiblesReturn>;
-declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectiblesReturn, Error, _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | {
+declare const fetchCollectibles: (args: UseListCollectiblesArgs, marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>, page: Page$1) => Promise<ListCollectiblesReturn>;
+declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectiblesReturn, Error, _tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, ListCollectiblesReturn, ("collectable" | "list" | {
     chainId: string;
     collectionAddress: `0x${string}`;
     side: OrderSide;
@@ -1065,7 +1097,7 @@ declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: S
     page: number;
     pageSize: number;
 }>, "queryFn"> & {
-    queryFn?: _tanstack_react_query.QueryFunction<ListCollectiblesReturn, (SequenceMarketplace | "collectable" | "list" | {
+    queryFn?: _tanstack_react_query.QueryFunction<ListCollectiblesReturn, ("collectable" | "list" | {
         chainId: string;
         collectionAddress: `0x${string}`;
         side: OrderSide;
@@ -1102,7 +1134,7 @@ declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: S
         pageSize: number;
     }> | undefined;
 } & {
-    queryKey: _tanstack_react_query.DataTag<(SequenceMarketplace | "collectable" | "list" | {
+    queryKey: _tanstack_react_query.DataTag<("collectable" | "list" | {
         chainId: string;
         collectionAddress: `0x${string}`;
         side: OrderSide;
@@ -1138,7 +1170,7 @@ declare const listCollectiblesOptions: (args: UseListCollectiblesArgs, config: S
 };
 declare const useListCollectibles: (args: UseListCollectiblesArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<ListCollectiblesReturn, unknown>, Error>;
 
-declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<z.objectUtil.extendShape<{
+declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<Omit<z.objectUtil.extendShape<{
     contractAddress: z.ZodString;
     tokenId: z.ZodString;
     filter: z.ZodOptional<z.ZodObject<{
@@ -1187,10 +1219,12 @@ declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<z.objectUtil.ex
     }>>;
 }, {
     chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
-}>, "strip", z.ZodTypeAny, {
+    collectionAddress: z.ZodString;
+    collectibleId: z.ZodString;
+}>, "tokenId" | "contractAddress">, "strip", z.ZodTypeAny, {
     chainId: string;
-    tokenId: string;
-    contractAddress: string;
+    collectionAddress: string;
+    collectibleId: string;
     filter?: {
         currencies?: string[] | undefined;
         marketplace?: MarketplaceKind[] | undefined;
@@ -1207,8 +1241,8 @@ declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<z.objectUtil.ex
     } | undefined;
 }, {
     chainId: string | number;
-    tokenId: string;
-    contractAddress: string;
+    collectionAddress: string;
+    collectibleId: string;
     filter?: {
         currencies?: string[] | undefined;
         marketplace?: MarketplaceKind[] | undefined;
@@ -1226,11 +1260,11 @@ declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<z.objectUtil.ex
 }>;
 type UseListOffersForCollectibleArgs = z.infer<typeof UseListOffersForCollectibleArgsSchema>;
 type UseListOffersForCollectibleReturn = Awaited<ReturnType<typeof fetchListOffersForCollectible>>;
-declare const fetchListOffersForCollectible: (config: SdkConfig, args: UseListOffersForCollectibleArgs, page: Page$1) => Promise<ListCollectibleOffersReturn>;
-declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseInfiniteQueryOptions<ListCollectibleOffersReturn, Error, _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>, ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | {
+declare const fetchListOffersForCollectible: (config: SdkConfig, args: UseListOffersForCollectibleArgs) => Promise<ListCollectibleOffersReturn>;
+declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListCollectibleOffersReturn, Error, ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | {
     chainId: string;
-    tokenId: string;
-    contractAddress: string;
+    collectionAddress: string;
+    collectibleId: string;
     filter?: {
         currencies?: string[] | undefined;
         marketplace?: MarketplaceKind[] | undefined;
@@ -1245,14 +1279,11 @@ declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibl
         }[] | undefined;
         more?: boolean | undefined;
     } | undefined;
-})[], {
-    page: number;
-    pageSize: number;
-}>, "queryFn"> & {
+})[]>, "queryFn"> & {
     queryFn?: _tanstack_react_query.QueryFunction<ListCollectibleOffersReturn, ("offers" | "collectable" | SdkConfig | {
         chainId: string;
-        tokenId: string;
-        contractAddress: string;
+        collectionAddress: string;
+        collectibleId: string;
         filter?: {
             currencies?: string[] | undefined;
             marketplace?: MarketplaceKind[] | undefined;
@@ -1267,15 +1298,164 @@ declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibl
             }[] | undefined;
             more?: boolean | undefined;
         } | undefined;
-    })[], {
+    })[], never> | undefined;
+} & {
+    queryKey: _tanstack_react_query.DataTag<("offers" | "collectable" | SdkConfig | {
+        chainId: string;
+        collectionAddress: string;
+        collectibleId: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+    })[], ListCollectibleOffersReturn>;
+};
+declare const useListOffersForCollectible: (args: UseListOffersForCollectibleArgs) => _tanstack_react_query.UseQueryResult<ListCollectibleOffersReturn, Error>;
+
+declare const UseListListingsForCollectibleArgsSchema: z.ZodObject<Omit<z.objectUtil.extendShape<{
+    contractAddress: z.ZodString;
+    tokenId: z.ZodString;
+    filter: z.ZodOptional<z.ZodObject<{
+        createdBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        marketplace: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+        currencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }, {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    }>>;
+    page: z.ZodOptional<z.ZodObject<{
+        page: z.ZodNumber;
+        pageSize: z.ZodNumber;
+        more: z.ZodOptional<z.ZodBoolean>;
+        sort: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            column: z.ZodString;
+            order: z.ZodNativeEnum<typeof SortOrder$1>;
+        }, "strip", z.ZodTypeAny, {
+            order: SortOrder$1;
+            column: string;
+        }, {
+            order: SortOrder$1;
+            column: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
         page: number;
         pageSize: number;
-    }> | undefined;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }, {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    }>>;
+}, {
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    collectionAddress: z.ZodString;
+    collectibleId: z.ZodString;
+}>, "tokenId" | "contractAddress">, "strip", z.ZodTypeAny, {
+    chainId: string;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+}, {
+    chainId: string | number;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+}>;
+type UseListListingsForCollectibleArgs = z.infer<typeof UseListListingsForCollectibleArgsSchema>;
+type UseListListingsForCollectibleReturn = Awaited<ReturnType<typeof fetchListListingsForCollectible>>;
+declare const fetchListListingsForCollectible: (config: SdkConfig, args: UseListListingsForCollectibleArgs) => Promise<ListCollectibleListingsReturn>;
+declare const listListingsForCollectibleOptions: (args: UseListListingsForCollectibleArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<ListCollectibleListingsReturn, Error, ListCollectibleListingsReturn, ("offers" | "collectable" | SdkConfig | {
+    chainId: string;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+        currencies?: string[] | undefined;
+        marketplace?: MarketplaceKind[] | undefined;
+        createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+        page: number;
+        pageSize: number;
+        sort?: {
+            order: SortOrder$1;
+            column: string;
+        }[] | undefined;
+        more?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<ListCollectibleListingsReturn, ("offers" | "collectable" | SdkConfig | {
+        chainId: string;
+        collectionAddress: string;
+        collectibleId: string;
+        filter?: {
+            currencies?: string[] | undefined;
+            marketplace?: MarketplaceKind[] | undefined;
+            createdBy?: string[] | undefined;
+        } | undefined;
+        page?: {
+            page: number;
+            pageSize: number;
+            sort?: {
+                order: SortOrder$1;
+                column: string;
+            }[] | undefined;
+            more?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
 } & {
     queryKey: _tanstack_react_query.DataTag<("offers" | "collectable" | SdkConfig | {
         chainId: string;
-        tokenId: string;
-        contractAddress: string;
+        collectionAddress: string;
+        collectibleId: string;
         filter?: {
             currencies?: string[] | undefined;
             marketplace?: MarketplaceKind[] | undefined;
@@ -1290,9 +1470,9 @@ declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibl
             }[] | undefined;
             more?: boolean | undefined;
         } | undefined;
-    })[], _tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>>;
+    })[], ListCollectibleListingsReturn>;
 };
-declare const useListOffersForCollectible: (args: UseListOffersForCollectibleArgs) => _tanstack_react_query.UseInfiniteQueryResult<_tanstack_react_query.InfiniteData<ListCollectibleOffersReturn, unknown>, Error>;
+declare const useListListingsForCollectible: (args: UseListListingsForCollectibleArgs) => _tanstack_react_query.UseQueryResult<ListCollectibleListingsReturn, Error>;
 
 declare const UseLowestListingSchema: z.ZodObject<z.objectUtil.extendShape<Omit<{
     contractAddress: z.ZodString;
@@ -1540,7 +1720,6 @@ type UseGenerateOfferTransactionArgs = {
     chainId: ChainId;
     onSuccess?: (data?: Step[]) => void;
 };
-
 type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
     expiry: Date;
 };
@@ -1618,6 +1797,236 @@ declare const useGenerateOfferTransaction: (params: UseGenerateOfferTransactionA
     submittedAt: number;
 };
 
+declare const UserGeneratSellTransactionArgsSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    onSuccess: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodNativeEnum<typeof StepType>;
+        data: z.ZodString;
+        to: z.ZodString;
+        value: z.ZodString;
+        signature: z.ZodOptional<z.ZodObject<{
+            domain: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+                chainId: z.ZodNumber;
+                verifyingContract: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            }, {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            }>;
+            types: z.ZodAny;
+            primaryType: z.ZodString;
+            value: z.ZodAny;
+        }, "strip", z.ZodTypeAny, {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        }, {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        }>>;
+        post: z.ZodOptional<z.ZodObject<{
+            endpoint: z.ZodString;
+            method: z.ZodString;
+            body: z.ZodAny;
+        }, "strip", z.ZodTypeAny, {
+            method: string;
+            endpoint: string;
+            body?: any;
+        }, {
+            method: string;
+            endpoint: string;
+            body?: any;
+        }>>;
+        executeType: z.ZodOptional<z.ZodNativeEnum<typeof ExecuteType>>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        id: StepType;
+        to: string;
+        data: string;
+        signature?: {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        } | undefined;
+        executeType?: ExecuteType | undefined;
+        post?: {
+            method: string;
+            endpoint: string;
+            body?: any;
+        } | undefined;
+    }, {
+        value: string;
+        id: StepType;
+        to: string;
+        data: string;
+        signature?: {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        } | undefined;
+        executeType?: ExecuteType | undefined;
+        post?: {
+            method: string;
+            endpoint: string;
+            body?: any;
+        } | undefined;
+    }>, "many">>], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    chainId: string;
+    onSuccess?: ((args_0: {
+        value: string;
+        id: StepType;
+        to: string;
+        data: string;
+        signature?: {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        } | undefined;
+        executeType?: ExecuteType | undefined;
+        post?: {
+            method: string;
+            endpoint: string;
+            body?: any;
+        } | undefined;
+    }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}, {
+    chainId: string | number;
+    onSuccess?: ((args_0: {
+        value: string;
+        id: StepType;
+        to: string;
+        data: string;
+        signature?: {
+            domain: {
+                version: string;
+                chainId: number;
+                name: string;
+                verifyingContract: string;
+            };
+            primaryType: string;
+            value?: any;
+            types?: any;
+        } | undefined;
+        executeType?: ExecuteType | undefined;
+        post?: {
+            method: string;
+            endpoint: string;
+            body?: any;
+        } | undefined;
+    }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}>;
+type UseGenerateSellTransactionArgs = z.infer<typeof UserGeneratSellTransactionArgsSchema>;
+declare const generateSellTransaction: (args: GenerateSellTransactionArgs, config: SdkConfig, chainId: ChainId) => Promise<Step[]>;
+declare const useGenerateSellTransaction: (params: UseGenerateSellTransactionArgs) => {
+    generateSellTransaction: _tanstack_react_query.UseMutateFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    generateSellTransactionAsync: _tanstack_react_query.UseMutateAsyncFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    data: undefined;
+    variables: undefined;
+    error: null;
+    isError: false;
+    isIdle: true;
+    isPending: false;
+    isSuccess: false;
+    status: "idle";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    generateSellTransaction: _tanstack_react_query.UseMutateFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    generateSellTransactionAsync: _tanstack_react_query.UseMutateAsyncFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    data: undefined;
+    variables: GenerateSellTransactionArgs;
+    error: null;
+    isError: false;
+    isIdle: false;
+    isPending: true;
+    isSuccess: false;
+    status: "pending";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    generateSellTransaction: _tanstack_react_query.UseMutateFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    generateSellTransactionAsync: _tanstack_react_query.UseMutateAsyncFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    data: undefined;
+    error: Error;
+    variables: GenerateSellTransactionArgs;
+    isError: true;
+    isIdle: false;
+    isPending: false;
+    isSuccess: false;
+    status: "error";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+} | {
+    generateSellTransaction: _tanstack_react_query.UseMutateFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    generateSellTransactionAsync: _tanstack_react_query.UseMutateAsyncFunction<Step[], Error, GenerateSellTransactionArgs, unknown>;
+    data: Step[];
+    error: null;
+    variables: GenerateSellTransactionArgs;
+    isError: false;
+    isIdle: false;
+    isPending: false;
+    isSuccess: true;
+    status: "success";
+    reset: () => void;
+    context: unknown;
+    failureCount: number;
+    failureReason: Error | null;
+    isPaused: boolean;
+    submittedAt: number;
+};
+
 interface BaseTransferParams {
     chainId: ChainId;
     collectionAddress: Hex;
@@ -1640,4 +2049,132 @@ declare const useTransferTokens: () => {
     transferSuccess: boolean;
 };
 
-export { type CreateReqWithDateExpiry$1 as CreateReqWithDateExpiry, type GenerateListingTransactionProps, type GenerateOfferTransactionProps, type TransferTokensParams, type UseCollectibleArgs, type UseCollectibleReturn, type UseCollectionArgs, type UseCollectionReturn, type UseContOfCollectableReturn, type UseCountOfCollectablesArgs, type UseCurrenciesReturn, type UseFetchTokenBalancesReturn, type UseFilterReturn, type UseFiltersArgs, type UseFloorOrderArgs, type UseFloorOrderReturn, type UseGenerateListingTransactionArgs, type UseGenerateOfferTransactionArgs, type UseHighestOfferArgs, type UseHighestOfferReturn, type UseListBalancesArgs, type UseListCollectiblesArgs, type UseListCollectiblesReturn, type UseListOffersForCollectibleReturn, type UseLowestListingArgs, type UseLowestListingReturn, balanceOfCollectibleOptions, collectibleOptions, collectionOptions, countOfCollectablesOptions, currenciesOptions, fetchFilters, filtersOptions, floorOrderOptions, generateListingTransaction, generateOfferTransaction, highestOfferOptions, listBalancesOptions, listCollectiblesOptions, listOffersForCollectibleOptions, lowestListingOptions, marketplaceConfigOptions, metadataOptionsSchema, royaletyPercentageOptions, useBalanceOfCollectible, useCollectible, useCollection, useConfig, useCountOfCollectables, useCurrencies, useFilters, useFloorOrder, useGenerateListingTransaction, useGenerateOfferTransaction, useHighestOffer, useListBalances, useListCollectibles, useListOffersForCollectible, useLowestListing, useMarketplaceConfig, useRoyaltyPercentage, useTransferTokens };
+declare const UseCheckoutOptionsSchema: z.ZodObject<{
+    chainId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodNativeEnum<typeof _0xsequence_network.ChainId>]>, z.ZodString>;
+    walletAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    orders: z.ZodArray<z.ZodObject<{
+        collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+        orderId: z.ZodString;
+        quantity: z.ZodNumber;
+        marketplace: z.ZodNativeEnum<typeof MarketplaceKind>;
+    }, "strip", z.ZodTypeAny, {
+        orderId: string;
+        marketplace: MarketplaceKind;
+        collectionAddress: `0x${string}`;
+        quantity: number;
+    }, {
+        orderId: string;
+        marketplace: MarketplaceKind;
+        collectionAddress: string;
+        quantity: number;
+    }>, "many">;
+    query: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    orders: {
+        orderId: string;
+        marketplace: MarketplaceKind;
+        collectionAddress: `0x${string}`;
+        quantity: number;
+    }[];
+    chainId: string;
+    walletAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}, {
+    orders: {
+        orderId: string;
+        marketplace: MarketplaceKind;
+        collectionAddress: string;
+        quantity: number;
+    }[];
+    chainId: string | number;
+    walletAddress: string;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseCheckoutOptionsArgs = z.infer<typeof UseCheckoutOptionsSchema>;
+type UseCheckoutOptionsReturn = Awaited<ReturnType<typeof fetchCheckoutOptions>>;
+declare const fetchCheckoutOptions: (args: UseCheckoutOptionsArgs, config: SdkConfig) => Promise<CheckoutOptionsMarketplaceReturn>;
+declare const checkoutOptionsOptions: (args: UseCheckoutOptionsArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<CheckoutOptionsMarketplaceReturn, Error, CheckoutOptionsMarketplaceReturn, (string | {
+    orders: {
+        orderId: string;
+        marketplace: MarketplaceKind;
+        collectionAddress: `0x${string}`;
+        quantity: number;
+    }[];
+    chainId: string;
+    walletAddress: `0x${string}`;
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+})[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<CheckoutOptionsMarketplaceReturn, (string | {
+        orders: {
+            orderId: string;
+            marketplace: MarketplaceKind;
+            collectionAddress: `0x${string}`;
+            quantity: number;
+        }[];
+        chainId: string;
+        walletAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], never> | undefined;
+} & {
+    queryKey: _tanstack_react_query.DataTag<(string | {
+        orders: {
+            orderId: string;
+            marketplace: MarketplaceKind;
+            collectionAddress: `0x${string}`;
+            quantity: number;
+        }[];
+        chainId: string;
+        walletAddress: `0x${string}`;
+        query?: {
+            enabled?: boolean | undefined;
+        } | undefined;
+    })[], CheckoutOptionsMarketplaceReturn>;
+};
+declare const useCheckoutOptions: (args: UseCheckoutOptionsArgs) => _tanstack_react_query.UseQueryResult<CheckoutOptionsMarketplaceReturn, Error>;
+
+declare const UseListCollectionsSchema: z.ZodObject<{
+    query: z.ZodDefault<z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        enabled?: boolean | undefined;
+    }, {
+        enabled?: boolean | undefined;
+    }>>>>;
+}, "strip", z.ZodTypeAny, {
+    query: {
+        enabled?: boolean | undefined;
+    };
+}, {
+    query?: {
+        enabled?: boolean | undefined;
+    } | undefined;
+}>;
+type UseListCollectionsArgs = z.input<typeof UseListCollectionsSchema>;
+type UseListCollectionsReturn = Awaited<ReturnType<typeof fetchListCollections>>;
+type FetchListCollectionsArgs = {
+    marketplaceConfig: MarketplaceConfig;
+    query?: z.infer<typeof QueryArgSchema>;
+};
+declare const fetchListCollections: ({ marketplaceConfig }: FetchListCollectionsArgs, config: SdkConfig) => Promise<_0xsequence_metadata.ContractInfo[]>;
+declare const listCollectionsOptions: (args: FetchListCollectionsArgs, config: SdkConfig) => _tanstack_react_query.OmitKeyof<_tanstack_react_query.UseQueryOptions<_0xsequence_metadata.ContractInfo[], Error, _0xsequence_metadata.ContractInfo[], ("collections" | "list")[]>, "queryFn"> & {
+    queryFn?: _tanstack_react_query.QueryFunction<_0xsequence_metadata.ContractInfo[], ("collections" | "list")[], never> | undefined;
+} & {
+    queryKey: _tanstack_react_query.DataTag<("collections" | "list")[], _0xsequence_metadata.ContractInfo[]>;
+};
+declare const useListCollections: (args?: UseListCollectionsArgs) => _tanstack_react_query.UseQueryResult<_0xsequence_metadata.ContractInfo[], Error>;
+
+export { type CreateReqWithDateExpiry$1 as CreateReqWithDateExpiry, type GenerateListingTransactionProps, type GenerateOfferTransactionProps, type TransferTokensParams, type UseCheckoutOptionsArgs, type UseCheckoutOptionsReturn, type UseCollectibleArgs, type UseCollectibleReturn, type UseCollectionArgs, type UseCollectionReturn, type UseContOfCollectableReturn, type UseCountOfCollectablesArgs, type UseCurrenciesReturn, type UseCurrencyReturn, type UseFetchTokenBalancesReturn, type UseFilterReturn, type UseFiltersArgs, type UseFloorOrderArgs, type UseFloorOrderReturn, type UseGenerateListingTransactionArgs, type UseGenerateOfferTransactionArgs, type UseHighestOfferArgs, type UseHighestOfferReturn, type UseListBalancesArgs, type UseListCollectiblesArgs, type UseListCollectiblesReturn, type UseListCollectionsArgs, type UseListCollectionsReturn, type UseListListingsForCollectibleReturn, type UseListOffersForCollectibleReturn, type UseLowestListingArgs, type UseLowestListingReturn, balanceOfCollectibleOptions, checkoutOptionsOptions, collectibleOptions, collectionOptions, countOfCollectablesOptions, currenciesOptions, currencyOptions, fetchFilters, filtersOptions, floorOrderOptions, generateListingTransaction, generateOfferTransaction, generateSellTransaction, highestOfferOptions, listBalancesOptions, listCollectiblesOptions, listCollectionsOptions, listListingsForCollectibleOptions, listOffersForCollectibleOptions, lowestListingOptions, marketplaceConfigOptions, metadataOptionsSchema, royaletyPercentageOptions, useBalanceOfCollectible, useCheckoutOptions, useCollectible, useCollection, useConfig, useCountOfCollectables, useCurrencies, useCurrency, useFilters, useFloorOrder, useGenerateListingTransaction, useGenerateOfferTransaction, useGenerateSellTransaction, useHighestOffer, useListBalances, useListCollectibles, useListCollections, useListListingsForCollectible, useListOffersForCollectible, useLowestListing, useMarketplaceConfig, useRoyaltyPercentage, useTransferTokens };