@0xsequence/marketplace-sdk 0.8.11 → 0.8.12

package/dist/index-BQW0PUkQ.d.ts

@@ -0,0 +1,3973 @@
+import { getMarketplaceClient } from "./index-BfH21xmk.js";
+import { Activity, CheckoutOptionsMarketplaceReturn, CheckoutOptionsSalesContractArgs, CheckoutOptionsSalesContractReturn, CollectibleCardAction, CollectibleOrder, Collection, CollectionFilterSettings, ContractType, CreateReq, Currency, CurrencyStatus, GenerateCancelTransactionArgs, GenerateListingTransactionArgs, GenerateOfferTransactionArgs, GenerateSellTransactionArgs, GetCountOfListingsForCollectibleReturn, GetCountOfOffersForCollectibleReturn, ListCollectibleListingsReturn, ListCollectibleOffersReturn, ListCollectiblesReturn, ListPrimarySaleItemsArgs, ListPrimarySaleItemsReturn, MarketplaceConfig, MarketplaceKind, MarketplaceType, Order, OrderSide, OrderbookKind, Page, PropertyFilter, PropertyType, SdkConfig, SortOrder, Step, StepType, TokenMetadata, WalletKind } from "./sdk-config-DJzxVPld.js";
+import { CollectiblesResponse, FetchTokenMetadataArgs, UseBalanceOfCollectibleArgs, UseHighestOfferArgs, UseInventoryArgs, UseListBalancesArgs, UseListCollectiblesArgs, UseLowestListingArgs, UseMarketCurrenciesArgs } from "./index-BHiSG-Yi.js";
+import { MarketCollectibleCardProps } from "./types-BIJOaL4j.js";
+import { z } from "zod";
+import * as _tanstack_react_query46 from "@tanstack/react-query";
+import * as _tanstack_react_query68 from "@tanstack/react-query";
+import * as _tanstack_react_query120 from "@tanstack/react-query";
+import * as _tanstack_react_query47 from "@tanstack/react-query";
+import * as _tanstack_react_query130 from "@tanstack/react-query";
+import * as _tanstack_react_query89 from "@tanstack/react-query";
+import * as _tanstack_react_query202 from "@tanstack/react-query";
+import * as _tanstack_react_query203 from "@tanstack/react-query";
+import * as _tanstack_react_query95 from "@tanstack/react-query";
+import * as _tanstack_react_query79 from "@tanstack/react-query";
+import * as _tanstack_react_query94 from "@tanstack/react-query";
+import * as _tanstack_react_query135 from "@tanstack/react-query";
+import * as _tanstack_react_query87 from "@tanstack/react-query";
+import * as _tanstack_react_query186 from "@tanstack/react-query";
+import * as _tanstack_react_query199 from "@tanstack/react-query";
+import * as _tanstack_react_query166 from "@tanstack/react-query";
+import * as _tanstack_react_query247 from "@tanstack/react-query";
+import * as _tanstack_react_query276 from "@tanstack/react-query";
+import * as _tanstack_react_query215 from "@tanstack/react-query";
+import * as _tanstack_react_query304 from "@tanstack/react-query";
+import * as _tanstack_react_query233 from "@tanstack/react-query";
+import * as _tanstack_react_query416 from "@tanstack/react-query";
+import * as _tanstack_react_query418 from "@tanstack/react-query";
+import * as _tanstack_react_query356 from "@tanstack/react-query";
+import * as _tanstack_react_query338 from "@tanstack/react-query";
+import * as _tanstack_react_query346 from "@tanstack/react-query";
+import * as _tanstack_react_query399 from "@tanstack/react-query";
+import * as _tanstack_react_query322 from "@tanstack/react-query";
+import * as _tanstack_react_query449 from "@tanstack/react-query";
+import * as _tanstack_react_query430 from "@tanstack/react-query";
+import * as _tanstack_react_query464 from "@tanstack/react-query";
+import * as _tanstack_react_query439 from "@tanstack/react-query";
+import * as _tanstack_react_query421 from "@tanstack/react-query";
+import * as _tanstack_react_query482 from "@tanstack/react-query";
+import * as _tanstack_react_query467 from "@tanstack/react-query";
+import * as _tanstack_react_query466 from "@tanstack/react-query";
+import * as _tanstack_react_query474 from "@tanstack/react-query";
+import { skipToken } from "@tanstack/react-query";
+import * as _0xsequence_indexer45 from "@0xsequence/indexer";
+import * as _0xsequence_indexer86 from "@0xsequence/indexer";
+import * as _0xsequence_indexer465 from "@0xsequence/indexer";
+import { GetTokenBalancesDetailsReturn } from "@0xsequence/indexer";
+import * as _0xsequence_metadata117 from "@0xsequence/metadata";
+import * as _0xsequence_metadata456 from "@0xsequence/metadata";
+import * as _0xsequence_metadata481 from "@0xsequence/metadata";
+import { PropertyFilter as PropertyFilter$1 } from "@0xsequence/metadata";
+import * as viem354 from "viem";
+import * as viem471 from "viem";
+import * as viem483 from "viem";
+import { Address, Hex } from "viem";
+import * as nuqs127 from "nuqs";
+
+//#region src/types/waas-types.d.ts
+type FeeOption = {
+  gasLimit: number;
+  to: string;
+  token: {
+    chainId: number;
+    contractAddress: string | null;
+    decimals: number;
+    logoURL: string;
+    name: string;
+    symbol: string;
+    tokenID: string | null;
+    type: string;
+  };
+  value: string;
+};
+//#endregion
+//#region src/react/hooks/useAutoSelectFeeOption.d.ts
+declare enum AutoSelectFeeOptionError {
+  UserNotConnected = "User not connected",
+  NoOptionsProvided = "No options provided",
+  FailedToCheckBalances = "Failed to check balances",
+  InsufficientBalanceForAnyFeeOption = "Insufficient balance for any fee option",
+}
+type UseAutoSelectFeeOptionArgs = {
+  pendingFeeOptionConfirmation: {
+    id: string;
+    options: FeeOption[] | undefined;
+    chainId: number;
+  };
+  enabled?: boolean;
+};
+/**
+ * A React hook that automatically selects the first fee option for which the user has sufficient balance.
+ *
+ * @param {Object} params.pendingFeeOptionConfirmation - Configuration for fee option selection
+ *
+ * @returns {Promise<{
+ *   selectedOption: FeeOption | null,
+ *   error: AutoSelectFeeOptionError | null,
+ *   isLoading?: boolean
+ * }>} A promise that resolves to an object containing:
+ *   - selectedOption: The first fee option with sufficient balance, or null if none found
+ *   - error: Error message if selection fails, null otherwise
+ *   - isLoading: True while checking balances
+ *
+ * @throws {AutoSelectFeeOptionError} Possible errors:
+ *   - UserNotConnected: When no wallet is connected
+ *   - NoOptionsProvided: When fee options array is undefined
+ *   - FailedToCheckBalances: When balance checking fails
+ *   - InsufficientBalanceForAnyFeeOption: When user has insufficient balance for all options
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const [pendingFeeOptionConfirmation, confirmPendingFeeOption] = useWaasFeeOptions();
+ *
+ *   const autoSelectOptionPromise = useAutoSelectFeeOption({
+ *     pendingFeeOptionConfirmation: pendingFeeOptionConfirmation
+ *       ? {
+ *           id: pendingFeeOptionConfirmation.id,
+ *           options: pendingFeeOptionConfirmation.options,
+ *           chainId: 1
+ *         }
+ *       : {
+ *           id: '',
+ *           options: undefined,
+ *           chainId: 1
+ *         }
+ *   });
+ *
+ *   useEffect(() => {
+ *     autoSelectOptionPromise.then((result) => {
+ *       if (result.isLoading) {
+ *         console.log('Checking balances...');
+ *         return;
+ *       }
+ *
+ *       if (result.error) {
+ *         console.error('Failed to select fee option:', result.error);
+ *         return;
+ *       }
+ *
+ *       if (pendingFeeOptionConfirmation?.id && result.selectedOption) {
+ *         confirmPendingFeeOption(
+ *           pendingFeeOptionConfirmation.id,
+ *           result.selectedOption.token.contractAddress
+ *         );
+ *       }
+ *     });
+ *   }, [autoSelectOptionPromise, confirmPendingFeeOption, pendingFeeOptionConfirmation]);
+ *
+ *   return <div>...</div>;
+ * }
+ * ```
+ */
+declare function useAutoSelectFeeOption({
+  pendingFeeOptionConfirmation,
+  enabled
+}: UseAutoSelectFeeOptionArgs): Promise<{
+  selectedOption: null;
+  error: AutoSelectFeeOptionError;
+  isLoading?: undefined;
+} | {
+  selectedOption: null;
+  error: null;
+  isLoading: boolean;
+} | {
+  selectedOption: FeeOption;
+  error: null;
+  isLoading?: undefined;
+}>;
+//#endregion
+//#region src/react/hooks/useBalanceOfCollectible.d.ts
+/**
+ * Hook to fetch the balance of a specific collectible for a user
+ *
+ * @param args - The arguments for fetching the balance
+ * @returns Query result containing the balance data
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error } = useBalanceOfCollectible({
+ *   collectionAddress: '0x123...',
+ *   collectableId: '1',
+ *   userAddress: '0x456...',
+ *   chainId: 1,
+ *   query: {
+ *     enabled: true,
+ *     refetchInterval: 10000,
+ *   }
+ * });
+ * ```
+ */
+declare function useBalanceOfCollectible(args: UseBalanceOfCollectibleArgs): _tanstack_react_query46.UseQueryResult<_0xsequence_indexer45.TokenBalance, Error>;
+//#endregion
+//#region src/react/hooks/useCountOfCollectables.d.ts
+declare const UseCountOfCollectableSchema: z.ZodUnion<[z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: 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;
+  }>>;
+} & {
+  filter: z.ZodObject<{
+    includeEmpty: z.ZodBoolean;
+    searchText: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodNativeEnum<typeof PropertyType>;
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+      values: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    }, "strip", z.ZodTypeAny, {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }, {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }>, "many">>;
+    marketplaces: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+    inAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    notInAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ordersCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ordersNotCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  }, {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  }>;
+  side: z.ZodNativeEnum<typeof OrderSide>;
+}, "strip", z.ZodTypeAny, {
+  filter: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  };
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  side: OrderSide;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  filter: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  };
+  chainId: number;
+  collectionAddress: string;
+  side: OrderSide;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>, z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: 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;
+  }>>;
+} & {
+  filter: z.ZodUndefined;
+  side: z.ZodUndefined;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  filter?: undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  side?: undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  filter?: undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  side?: undefined;
+}>]>;
+type UseCountOfCollectablesArgs = z.infer<typeof UseCountOfCollectableSchema>;
+type UseContOfCollectableReturn = Awaited<ReturnType<typeof fetchCountOfCollectables>>;
+declare const fetchCountOfCollectables: (args: UseCountOfCollectablesArgs, config: SdkConfig) => Promise<number>;
+declare const countOfCollectablesOptions: (args: UseCountOfCollectablesArgs, config: SdkConfig) => _tanstack_react_query68.OmitKeyof<_tanstack_react_query68.UseQueryOptions<number, Error, number, ("collectable" | "counts" | {
+  filter: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  };
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  side: OrderSide;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+} | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  filter?: undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  side?: undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query68.QueryFunction<number, ("collectable" | "counts" | {
+    filter: {
+      includeEmpty: boolean;
+      searchText?: string | undefined;
+      properties?: {
+        name: string;
+        type: PropertyType;
+        values?: any[] | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+      }[] | undefined;
+      marketplaces?: MarketplaceKind[] | undefined;
+      inAccounts?: string[] | undefined;
+      notInAccounts?: string[] | undefined;
+      ordersCreatedBy?: string[] | undefined;
+      ordersNotCreatedBy?: string[] | undefined;
+    };
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  } | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    filter?: undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+    side?: undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: ("collectable" | "counts" | {
+    filter: {
+      includeEmpty: boolean;
+      searchText?: string | undefined;
+      properties?: {
+        name: string;
+        type: PropertyType;
+        values?: any[] | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+      }[] | undefined;
+      marketplaces?: MarketplaceKind[] | undefined;
+      inAccounts?: string[] | undefined;
+      notInAccounts?: string[] | undefined;
+      ordersCreatedBy?: string[] | undefined;
+      ordersNotCreatedBy?: string[] | undefined;
+    };
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    side: OrderSide;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  } | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    filter?: undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+    side?: undefined;
+  })[] & {
+    [dataTagSymbol]: number;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCountOfCollectables: (args: UseCountOfCollectablesArgs) => _tanstack_react_query68.UseQueryResult<number, Error>;
+//#endregion
+//#region src/react/hooks/useCollectible.d.ts
+declare const UseCollectibleSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  collectibleId: z.ZodOptional<z.ZodString>;
+  query: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  collectibleId?: string | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  collectibleId?: string | undefined;
+}>;
+type UseCollectibleArgs = z.infer<typeof UseCollectibleSchema>;
+type UseCollectibleReturn = Awaited<ReturnType<typeof fetchCollectible>>;
+declare const fetchCollectible: (args: UseCollectibleArgs, config: SdkConfig) => Promise<_0xsequence_metadata117.TokenMetadata>;
+declare const collectibleOptions: (args: UseCollectibleArgs, config: SdkConfig) => _tanstack_react_query120.OmitKeyof<_tanstack_react_query120.UseQueryOptions<_0xsequence_metadata117.TokenMetadata, Error, _0xsequence_metadata117.TokenMetadata, (SdkConfig | "collectable" | "details" | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  collectibleId?: string | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query120.QueryFunction<_0xsequence_metadata117.TokenMetadata, (SdkConfig | "collectable" | "details" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+    collectibleId?: string | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "details" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+    collectibleId?: string | undefined;
+  })[] & {
+    [dataTagSymbol]: _0xsequence_metadata117.TokenMetadata;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCollectible: (args: UseCollectibleArgs) => _tanstack_react_query120.UseQueryResult<_0xsequence_metadata117.TokenMetadata, Error>;
+//#endregion
+//#region src/react/hooks/useCollectionBalanceDetails.d.ts
+declare const filterSchema: z.ZodObject<{
+  accountAddresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+  contractWhitelist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">>;
+  omitNativeBalances: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+  accountAddresses: `0x${string}`[];
+  omitNativeBalances: boolean;
+  contractWhitelist?: `0x${string}`[] | undefined;
+}, {
+  accountAddresses: string[];
+  omitNativeBalances: boolean;
+  contractWhitelist?: string[] | undefined;
+}>;
+declare const useCollectionBalanceDetailsArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  filter: z.ZodObject<{
+    accountAddresses: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
+    contractWhitelist: z.ZodOptional<z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">>;
+    omitNativeBalances: z.ZodBoolean;
+  }, "strip", z.ZodTypeAny, {
+    accountAddresses: `0x${string}`[];
+    omitNativeBalances: boolean;
+    contractWhitelist?: `0x${string}`[] | undefined;
+  }, {
+    accountAddresses: string[];
+    omitNativeBalances: boolean;
+    contractWhitelist?: string[] | undefined;
+  }>;
+  query: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>>;
+}, "strip", z.ZodTypeAny, {
+  filter: {
+    accountAddresses: `0x${string}`[];
+    omitNativeBalances: boolean;
+    contractWhitelist?: `0x${string}`[] | undefined;
+  };
+  chainId: number;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  filter: {
+    accountAddresses: string[];
+    omitNativeBalances: boolean;
+    contractWhitelist?: string[] | undefined;
+  };
+  chainId: number;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type CollectionBalanceFilter = z.infer<typeof filterSchema>;
+type UseCollectionBalanceDetailsArgs = z.input<typeof useCollectionBalanceDetailsArgsSchema>;
+declare const collectionBalanceDetailsOptions: (args: UseCollectionBalanceDetailsArgs, config: SdkConfig) => _tanstack_react_query47.OmitKeyof<_tanstack_react_query47.UseQueryOptions<GetTokenBalancesDetailsReturn, Error, GetTokenBalancesDetailsReturn, (SdkConfig | "balances" | "collectionBalanceDetails" | {
+  filter: {
+    accountAddresses: string[];
+    omitNativeBalances: boolean;
+    contractWhitelist?: string[] | undefined;
+  };
+  chainId: number;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query47.QueryFunction<GetTokenBalancesDetailsReturn, (SdkConfig | "balances" | "collectionBalanceDetails" | {
+    filter: {
+      accountAddresses: string[];
+      omitNativeBalances: boolean;
+      contractWhitelist?: string[] | undefined;
+    };
+    chainId: number;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "balances" | "collectionBalanceDetails" | {
+    filter: {
+      accountAddresses: string[];
+      omitNativeBalances: boolean;
+      contractWhitelist?: string[] | undefined;
+    };
+    chainId: number;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: GetTokenBalancesDetailsReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCollectionBalanceDetails: (args: UseCollectionBalanceDetailsArgs) => _tanstack_react_query47.UseQueryResult<GetTokenBalancesDetailsReturn, Error>;
+//#endregion
+//#region src/react/hooks/useComparePrices.d.ts
+declare const UseComparePricesArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  priceAmountRaw: z.ZodString;
+  priceCurrencyAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  compareToPriceAmountRaw: z.ZodString;
+  compareToPriceCurrencyAddress: 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: number;
+  priceAmountRaw: string;
+  priceCurrencyAddress: `0x${string}`;
+  compareToPriceAmountRaw: string;
+  compareToPriceCurrencyAddress: `0x${string}`;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  priceAmountRaw: string;
+  priceCurrencyAddress: string;
+  compareToPriceAmountRaw: string;
+  compareToPriceCurrencyAddress: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseComparePricesArgs = z.input<typeof UseComparePricesArgsSchema>;
+type UseComparePricesReturn = {
+  percentageDifference: number;
+  percentageDifferenceFormatted: string;
+  status: 'above' | 'same' | 'below';
+};
+declare const comparePricesOptions: (args: UseComparePricesArgs, config: SdkConfig) => _tanstack_react_query130.OmitKeyof<_tanstack_react_query130.UseQueryOptions<UseComparePricesReturn, Error, UseComparePricesReturn, (string | {
+  chainId: number;
+  priceAmountRaw: string;
+  priceCurrencyAddress: string;
+  compareToPriceAmountRaw: string;
+  compareToPriceCurrencyAddress: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query130.QueryFunction<UseComparePricesReturn, (string | {
+    chainId: number;
+    priceAmountRaw: string;
+    priceCurrencyAddress: string;
+    compareToPriceAmountRaw: string;
+    compareToPriceCurrencyAddress: string;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (string | {
+    chainId: number;
+    priceAmountRaw: string;
+    priceCurrencyAddress: string;
+    compareToPriceAmountRaw: string;
+    compareToPriceCurrencyAddress: string;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: UseComparePricesReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+/**
+ * Hook to compare prices between different currencies by converting both to USD
+ * @param args - The arguments for the hook
+ * @returns The percentage difference between the two prices
+ * @example
+ * ```ts
+ * const { data } = useComparePrices({
+ *   chainId: 1,
+ *   priceAmountRaw: "1000000000000000000",
+ *   priceCurrencyAddress: "0x0000000000000000000000000000000000000000",
+ * });
+ *
+ * console.log(data);
+ * // { percentageDifference: 10, percentageDifferenceFormatted: "10.00", isAbove: true, isSame: false, isBelow: false }
+ * ```
+ */
+declare const useComparePrices: (args: UseComparePricesArgs) => _tanstack_react_query130.UseQueryResult<UseComparePricesReturn, Error>;
+//#endregion
+//#region src/react/hooks/useConfig.d.ts
+declare function useConfig(): SdkConfig;
+//#endregion
+//#region src/react/hooks/useConvertPriceToUSD.d.ts
+declare const UseConvertPriceToUSDArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  currencyAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  amountRaw: z.ZodString;
+  query: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  currencyAddress: `0x${string}`;
+  amountRaw: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  currencyAddress: string;
+  amountRaw: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseConvertPriceToUSDArgs = z.input<typeof UseConvertPriceToUSDArgsSchema>;
+type UseConvertPriceToUSDReturn = {
+  usdAmount: number;
+  usdAmountFormatted: string;
+};
+declare const convertPriceToUSD: (args: UseConvertPriceToUSDArgs, config: SdkConfig) => Promise<UseConvertPriceToUSDReturn>;
+declare const convertPriceToUSDOptions: (args: UseConvertPriceToUSDArgs, config: SdkConfig) => _tanstack_react_query89.OmitKeyof<_tanstack_react_query89.UseQueryOptions<UseConvertPriceToUSDReturn, Error, UseConvertPriceToUSDReturn, (string | number)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query89.QueryFunction<UseConvertPriceToUSDReturn, (string | number)[], never> | undefined;
+} & {
+  queryKey: (string | number)[] & {
+    [dataTagSymbol]: UseConvertPriceToUSDReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+/**
+ * Hook to convert a price amount from a specific currency to USD
+ * @returns The price amount in USD and formatted USD amount
+ * @example
+ * ```ts
+ * const { data } = useConvertPriceToUSD({
+ *   chainId: 1,
+ *   currencyAddress: "0x0000000000000000000000000000000000000000",
+ *   amountRaw: "1000000000000000000",
+ * });
+ *
+ * console.log(data);
+ * // { usdAmount: 1000, usdAmountFormatted: "1000.00" }
+ * ```
+ */
+declare const useConvertPriceToUSD: (args: UseConvertPriceToUSDArgs) => _tanstack_react_query89.UseQueryResult<UseConvertPriceToUSDReturn, Error>;
+//#endregion
+//#region src/react/hooks/useMarketCurrencies.d.ts
+declare const useMarketCurrencies: (args: UseMarketCurrenciesArgs) => _tanstack_react_query202.UseQueryResult<{
+  contractAddress: string;
+  chainId: number;
+  status: CurrencyStatus;
+  name: string;
+  symbol: string;
+  decimals: number;
+  imageUrl: string;
+  exchangeRate: number;
+  defaultChainCurrency: boolean;
+  nativeCurrency: boolean;
+  createdAt: string;
+  updatedAt: string;
+  deletedAt?: string;
+}[], Error>;
+//#endregion
+//#region src/react/hooks/useCurrency.d.ts
+declare const UseCurrencyArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  currencyAddress: z.ZodOptional<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: number;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  currencyAddress?: `0x${string}` | undefined;
+}, {
+  chainId: number;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+  currencyAddress?: string | undefined;
+}>;
+type UseCurrencyArgs = z.input<typeof UseCurrencyArgsSchema>;
+type UseCurrencyReturn = Currency | undefined;
+declare const currencyOptions: (args: UseCurrencyArgs, config: SdkConfig) => _tanstack_react_query203.UseQueryOptions<Currency | undefined, Error, Currency | undefined, (string | number | undefined)[]> & {
+  initialData?: Currency | _tanstack_react_query203.InitialDataFunction<Currency> | undefined;
+} & {
+  queryKey: (string | number | undefined)[] & {
+    [dataTagSymbol]: Currency | undefined;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCurrency: (args: UseCurrencyArgs) => _tanstack_react_query203.UseQueryResult<Currency | undefined, Error>;
+//#endregion
+//#region src/react/hooks/useFilters.d.ts
+type UseFiltersArgs = {
+  chainId: number;
+  collectionAddress: string;
+  showAllFilters?: boolean;
+  excludePropertyValues?: boolean;
+  query?: {
+    enabled?: boolean;
+  };
+};
+type UseFilterReturn = Awaited<ReturnType<typeof fetchFilters>>;
+declare const fetchFilters: (args: UseFiltersArgs, config: SdkConfig) => Promise<PropertyFilter$1[]>;
+declare const filtersOptions: (args: UseFiltersArgs, config: SdkConfig) => _tanstack_react_query95.OmitKeyof<_tanstack_react_query95.UseQueryOptions<PropertyFilter$1[], Error, PropertyFilter$1[], ("filter" | SdkConfig | "collectable" | UseFiltersArgs)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query95.QueryFunction<PropertyFilter$1[], ("filter" | SdkConfig | "collectable" | UseFiltersArgs)[], never> | undefined;
+} & {
+  queryKey: ("filter" | SdkConfig | "collectable" | UseFiltersArgs)[] & {
+    [dataTagSymbol]: PropertyFilter$1[];
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useFilters: (args: UseFiltersArgs) => _tanstack_react_query95.UseQueryResult<PropertyFilter$1[], Error>;
+declare const useFiltersProgressive: (args: UseFiltersArgs) => {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: PropertyFilter$1[];
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+} | {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: PropertyFilter$1[];
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+} | {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: undefined;
+  error: Error;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+} | {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+} | {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: undefined;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+} | {
+  isFetchingValues: boolean;
+  isLoadingNames: boolean;
+  data: PropertyFilter$1[];
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: Error | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query95.RefetchOptions) => Promise<_tanstack_react_query95.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query95.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+};
+//#endregion
+//#region src/react/hooks/useFilterState.d.ts
+interface StringFilterValues {
+  type: PropertyType.STRING;
+  values: string[];
+}
+interface IntFilterValues {
+  type: PropertyType.INT;
+  min: number;
+  max: number;
+}
+type FilterValues = StringFilterValues | IntFilterValues;
+declare function useFilterState(): {
+  serialize: {
+    (values: Partial<{
+      filters: PropertyFilter[] | null;
+      search: string | null;
+      listedOnly: boolean | null;
+    }>): string;
+    (base: string | URLSearchParams | URL, values: Partial<{
+      filters: PropertyFilter[] | null;
+      search: string | null;
+      listedOnly: boolean | null;
+    }> | null): string;
+  };
+  getFilter: (name: string) => PropertyFilter | undefined;
+  getFilterValues: (name: string) => FilterValues | undefined;
+  isFilterActive: (name: string) => boolean;
+  isStringValueSelected: (name: string, value: string) => boolean;
+  isIntFilterActive: (name: string) => boolean;
+  getIntFilterRange: (name: string) => [number, number] | undefined;
+  deleteFilter: (name: string) => void;
+  toggleStringFilterValue: (name: string, value: string) => void;
+  setIntFilterValue: (name: string, min: number, max: number) => void;
+  clearAllFilters: () => void;
+  filterOptions: PropertyFilter[];
+  searchText: string;
+  showListedOnly: boolean;
+  setFilterOptions: (value: PropertyFilter[] | ((old: PropertyFilter[]) => PropertyFilter[] | null) | null, options?: nuqs127.Options) => Promise<URLSearchParams>;
+  setSearchText: (value: string | ((old: string) => string | null) | null, options?: nuqs127.Options) => Promise<URLSearchParams>;
+  setShowListedOnly: (value: boolean | ((old: boolean) => boolean | null) | null, options?: nuqs127.Options) => Promise<URLSearchParams>;
+};
+//#endregion
+//#region src/react/hooks/useFloorOrder.d.ts
+declare const UseFloorOrderSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: 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: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseFloorOrderArgs = z.infer<typeof UseFloorOrderSchema>;
+type UseFloorOrderReturn = Awaited<ReturnType<typeof fetchFloorOrder>>;
+declare const fetchFloorOrder: (args: UseFloorOrderArgs, config: SdkConfig) => Promise<CollectibleOrder>;
+declare const floorOrderOptions: (args: UseFloorOrderArgs, config: SdkConfig) => _tanstack_react_query79.OmitKeyof<_tanstack_react_query79.UseQueryOptions<CollectibleOrder, Error, CollectibleOrder, (SdkConfig | "collectable" | "floorOrders" | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query79.QueryFunction<CollectibleOrder, (SdkConfig | "collectable" | "floorOrders" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "floorOrders" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: CollectibleOrder;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useFloorOrder: (args: UseFloorOrderArgs) => _tanstack_react_query79.UseQueryResult<CollectibleOrder, Error>;
+//#endregion
+//#region src/react/hooks/useHighestOffer.d.ts
+declare function useHighestOffer(args: UseHighestOfferArgs): _tanstack_react_query94.UseQueryResult<Order | null, Error>;
+//#endregion
+//#region src/react/hooks/useInventory.d.ts
+declare function useInventory(args: UseInventoryArgs): _tanstack_react_query135.UseInfiniteQueryResult<_tanstack_react_query135.InfiniteData<CollectiblesResponse, unknown>, Error>;
+//#endregion
+//#region src/react/hooks/useListBalances.d.ts
+/**
+ * Hook to fetch a list of token balances with pagination support
+ *
+ * @param args - The arguments for fetching the balances
+ * @returns Infinite query result containing the balances data
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error, fetchNextPage } = useListBalances({
+ *   chainId: 1,
+ *   accountAddress: '0x123...',
+ *   includeMetadata: true,
+ *   query: {
+ *     enabled: true,
+ *     refetchInterval: 10000,
+ *   }
+ * });
+ * ```
+ */
+declare function useListBalances(args: UseListBalancesArgs): _tanstack_react_query87.UseInfiniteQueryResult<_tanstack_react_query87.InfiniteData<_0xsequence_indexer86.GetTokenBalancesReturn, unknown>, Error>;
+//#endregion
+//#region src/react/_internal/api/zod-schema.d.ts
+
+declare const getListCollectibleActivitiesArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  tokenId: z.ZodPipeline<z.ZodUnion<[z.ZodString, z.ZodNumber]>, z.ZodString>;
+  query: 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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  } & {
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  tokenId: string;
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  tokenId: string | number;
+  chainId: number;
+  collectionAddress: string;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+declare const getListCollectibleActivitiesReturnSchema: z.ZodObject<{
+  activities: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    fromAddress: z.ZodString;
+    toAddress: z.ZodString;
+    txHash: z.ZodString;
+    timestamp: z.ZodNumber;
+    tokenId: z.ZodString;
+    tokenImage: z.ZodString;
+    tokenName: z.ZodString;
+    currency: z.ZodOptional<z.ZodObject<{
+      chainId: z.ZodNumber;
+      contractAddress: z.ZodString;
+      name: z.ZodString;
+      symbol: z.ZodString;
+      decimals: z.ZodNumber;
+      imageUrl: z.ZodString;
+      exchangeRate: z.ZodNumber;
+      defaultChainCurrency: z.ZodBoolean;
+      nativeCurrency: z.ZodBoolean;
+      createdAt: z.ZodString;
+      updatedAt: z.ZodString;
+      deletedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    }, {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    }>>;
+  }, "strip", z.ZodTypeAny, {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }, {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }>, "many">;
+  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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  activities: {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }[];
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  activities: {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }[];
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+declare const getListCollectionActivitiesArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  query: 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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  } & {
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+declare const getListCollectionActivitiesReturnSchema: z.ZodObject<{
+  activities: z.ZodArray<z.ZodObject<{
+    type: z.ZodString;
+    fromAddress: z.ZodString;
+    toAddress: z.ZodString;
+    txHash: z.ZodString;
+    timestamp: z.ZodNumber;
+    tokenId: z.ZodString;
+    tokenImage: z.ZodString;
+    tokenName: z.ZodString;
+    currency: z.ZodOptional<z.ZodObject<{
+      chainId: z.ZodNumber;
+      contractAddress: z.ZodString;
+      name: z.ZodString;
+      symbol: z.ZodString;
+      decimals: z.ZodNumber;
+      imageUrl: z.ZodString;
+      exchangeRate: z.ZodNumber;
+      defaultChainCurrency: z.ZodBoolean;
+      nativeCurrency: z.ZodBoolean;
+      createdAt: z.ZodString;
+      updatedAt: z.ZodString;
+      deletedAt: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    }, {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    }>>;
+  }, "strip", z.ZodTypeAny, {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }, {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }>, "many">;
+  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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  activities: {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }[];
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  activities: {
+    tokenId: string;
+    type: string;
+    fromAddress: string;
+    toAddress: string;
+    txHash: string;
+    timestamp: number;
+    tokenImage: string;
+    tokenName: string;
+    currency?: {
+      symbol: string;
+      contractAddress: string;
+      name: string;
+      chainId: number;
+      decimals: number;
+      nativeCurrency: boolean;
+      imageUrl: string;
+      exchangeRate: number;
+      defaultChainCurrency: boolean;
+      createdAt: string;
+      updatedAt: string;
+      deletedAt?: string | undefined;
+    } | undefined;
+  }[];
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+//#endregion
+//#region src/react/hooks/useListCollectibleActivities.d.ts
+type UseListCollectibleActivitiesArgs = z.infer<typeof getListCollectibleActivitiesArgsSchema>;
+type UseListCollectibleActivitiesReturn = z.infer<typeof getListCollectibleActivitiesReturnSchema>;
+declare const listCollectibleActivitiesOptions: (args: UseListCollectibleActivitiesArgs, config: SdkConfig) => _tanstack_react_query186.OmitKeyof<_tanstack_react_query186.UseQueryOptions<{
+  activities: Activity[];
+  page: Page | undefined;
+}, Error, {
+  activities: Activity[];
+  page: Page | undefined;
+}, (SdkConfig | "collectable" | "collectibleActivities" | {
+  tokenId: string;
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query186.QueryFunction<{
+    activities: Activity[];
+    page: Page | undefined;
+  }, (SdkConfig | "collectable" | "collectibleActivities" | {
+    tokenId: string;
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "collectibleActivities" | {
+    tokenId: string;
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: {
+      activities: Activity[];
+      page: Page | undefined;
+    };
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListCollectibleActivities: (args: UseListCollectibleActivitiesArgs) => _tanstack_react_query186.UseQueryResult<{
+  activities: Activity[];
+  page: Page | undefined;
+}, Error>;
+//#endregion
+//#region src/react/hooks/useListCollectibles.d.ts
+/**
+ * Hook to fetch a list of collectibles with pagination support
+ *
+ * @param args - The arguments for fetching the collectibles
+ * @returns Infinite query result containing the collectibles data including orders
+ *
+ * @example
+ * ```tsx
+ * const { data, isLoading, error, fetchNextPage } = useListCollectibles({
+ *   chainId: 1,
+ *   collectionAddress: '0x123...',
+ *   includeMetadata: true,
+ *   query: {
+ *     enabled: true,
+ *     refetchInterval: 10000,
+ *   }
+ * });
+ * ```
+ */
+declare function useListCollectibles(args: UseListCollectiblesArgs): _tanstack_react_query199.UseInfiniteQueryResult<_tanstack_react_query199.InfiniteData<ListCollectiblesReturn, unknown>, Error>;
+//#endregion
+//#region src/react/hooks/useListCollectiblesPaginated.d.ts
+declare const UseListCollectiblesPaginatedArgsSchema: z.ZodObject<Omit<{
+  side: z.ZodNativeEnum<typeof OrderSide>;
+  contractAddress: z.ZodString;
+  filter: z.ZodOptional<z.ZodObject<{
+    includeEmpty: z.ZodBoolean;
+    searchText: z.ZodOptional<z.ZodString>;
+    properties: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      name: z.ZodString;
+      type: z.ZodNativeEnum<typeof PropertyType>;
+      min: z.ZodOptional<z.ZodNumber>;
+      max: z.ZodOptional<z.ZodNumber>;
+      values: z.ZodOptional<z.ZodArray<z.ZodAny, "many">>;
+    }, "strip", z.ZodTypeAny, {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }, {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }>, "many">>;
+    marketplaces: z.ZodOptional<z.ZodArray<z.ZodNativeEnum<typeof MarketplaceKind>, "many">>;
+    inAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    notInAccounts: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ordersCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    ordersNotCreatedBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  }, {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: 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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+}, "contractAddress"> & {
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  chainId: z.ZodNumber;
+  query: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    pageSize: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+  }>>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+  };
+  side: OrderSide;
+  filter?: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  side: OrderSide;
+  filter?: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+    page?: number | undefined;
+    pageSize?: number | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+type UseListCollectiblesPaginatedArgs = z.infer<typeof UseListCollectiblesPaginatedArgsSchema>;
+type UseListCollectiblesPaginatedReturn = Awaited<ReturnType<typeof fetchCollectiblesPaginated>>;
+declare const fetchCollectiblesPaginated: (args: UseListCollectiblesPaginatedArgs, marketplaceClient: Awaited<ReturnType<typeof getMarketplaceClient>>) => Promise<ListCollectiblesReturn>;
+declare const listCollectiblesPaginatedOptions: (args: UseListCollectiblesPaginatedArgs, config: SdkConfig) => _tanstack_react_query166.OmitKeyof<_tanstack_react_query166.UseQueryOptions<ListCollectiblesReturn, Error, ListCollectiblesReturn, (string | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+  };
+  side: OrderSide;
+  filter?: {
+    includeEmpty: boolean;
+    searchText?: string | undefined;
+    properties?: {
+      name: string;
+      type: PropertyType;
+      values?: any[] | undefined;
+      max?: number | undefined;
+      min?: number | undefined;
+    }[] | undefined;
+    marketplaces?: MarketplaceKind[] | undefined;
+    inAccounts?: string[] | undefined;
+    notInAccounts?: string[] | undefined;
+    ordersCreatedBy?: string[] | undefined;
+    ordersNotCreatedBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query166.QueryFunction<ListCollectiblesReturn, (string | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+    };
+    side: OrderSide;
+    filter?: {
+      includeEmpty: boolean;
+      searchText?: string | undefined;
+      properties?: {
+        name: string;
+        type: PropertyType;
+        values?: any[] | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+      }[] | undefined;
+      marketplaces?: MarketplaceKind[] | undefined;
+      inAccounts?: string[] | undefined;
+      notInAccounts?: string[] | undefined;
+      ordersCreatedBy?: string[] | undefined;
+      ordersNotCreatedBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (string | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+    };
+    side: OrderSide;
+    filter?: {
+      includeEmpty: boolean;
+      searchText?: string | undefined;
+      properties?: {
+        name: string;
+        type: PropertyType;
+        values?: any[] | undefined;
+        max?: number | undefined;
+        min?: number | undefined;
+      }[] | undefined;
+      marketplaces?: MarketplaceKind[] | undefined;
+      inAccounts?: string[] | undefined;
+      notInAccounts?: string[] | undefined;
+      ordersCreatedBy?: string[] | undefined;
+      ordersNotCreatedBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: ListCollectiblesReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListCollectiblesPaginated: (args: UseListCollectiblesPaginatedArgs) => _tanstack_react_query166.UseQueryResult<ListCollectiblesReturn, Error>;
+//#endregion
+//#region src/react/hooks/useListCollectionActivities.d.ts
+type UseListCollectionActivitiesArgs = z.infer<typeof getListCollectionActivitiesArgsSchema>;
+type UseListCollectionActivitiesReturn = z.infer<typeof getListCollectionActivitiesReturnSchema>;
+declare const listCollectionActivitiesOptions: (args: UseListCollectionActivitiesArgs, config: SdkConfig) => _tanstack_react_query247.OmitKeyof<_tanstack_react_query247.UseQueryOptions<{
+  activities: Activity[];
+  page: Page | undefined;
+}, Error, {
+  activities: Activity[];
+  page: Page | undefined;
+}, (SdkConfig | "collections" | "collectionActivities" | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  query?: {
+    page: number;
+    pageSize: number;
+    enabled?: boolean | undefined;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query247.QueryFunction<{
+    activities: Activity[];
+    page: Page | undefined;
+  }, (SdkConfig | "collections" | "collectionActivities" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collections" | "collectionActivities" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    query?: {
+      page: number;
+      pageSize: number;
+      enabled?: boolean | undefined;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: {
+      activities: Activity[];
+      page: Page | undefined;
+    };
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListCollectionActivities: (args: UseListCollectionActivitiesArgs) => _tanstack_react_query247.UseQueryResult<{
+  activities: Activity[];
+  page: Page | undefined;
+}, Error>;
+//#endregion
+//#region src/react/hooks/useListOffersForCollectible.d.ts
+declare const UseListOffersForCollectibleArgsSchema: z.ZodObject<Omit<{
+  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, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | 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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+} & {
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodString;
+  collectibleId: z.ZodString;
+}, "tokenId" | "contractAddress">, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}>;
+type UseListOffersForCollectibleArgs = z.infer<typeof UseListOffersForCollectibleArgsSchema>;
+type UseListOffersForCollectibleReturn = Awaited<ReturnType<typeof fetchListOffersForCollectible>>;
+declare const fetchListOffersForCollectible: (config: SdkConfig, args: UseListOffersForCollectibleArgs) => Promise<ListCollectibleOffersReturn>;
+declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query276.OmitKeyof<_tanstack_react_query276.UseQueryOptions<ListCollectibleOffersReturn, Error, ListCollectibleOffersReturn, (SdkConfig | "collectable" | "offers" | {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query276.QueryFunction<ListCollectibleOffersReturn, (SdkConfig | "collectable" | "offers" | {
+    chainId: number;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "offers" | {
+    chainId: number;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: ListCollectibleOffersReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListOffersForCollectible: (args: UseListOffersForCollectibleArgs) => _tanstack_react_query276.UseQueryResult<ListCollectibleOffersReturn, Error>;
+//#endregion
+//#region src/react/hooks/useCountOffersForCollectible.d.ts
+declare const UseCountOffersForCollectibleArgsSchema: z.ZodObject<Omit<{
+  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, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }>>;
+}, "tokenId" | "contractAddress"> & {
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  collectibleId: z.ZodString;
+  chainId: z.ZodNumber;
+  query: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseCountOffersForCollectibleArgs = z.infer<typeof UseCountOffersForCollectibleArgsSchema>;
+type UseCountOffersForCollectibleReturn = Awaited<ReturnType<typeof fetchCountOffersForCollectible>>;
+declare const fetchCountOffersForCollectible: (args: UseCountOffersForCollectibleArgs, config: SdkConfig) => Promise<GetCountOfOffersForCollectibleReturn>;
+declare const countOffersForCollectibleOptions: (args: UseCountOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query215.OmitKeyof<_tanstack_react_query215.UseQueryOptions<GetCountOfOffersForCollectibleReturn, Error, GetCountOfOffersForCollectibleReturn, (SdkConfig | "collectable" | "offersCount" | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query215.QueryFunction<GetCountOfOffersForCollectibleReturn, (SdkConfig | "collectable" | "offersCount" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "offersCount" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: GetCountOfOffersForCollectibleReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCountOffersForCollectible: (args: UseCountOffersForCollectibleArgs) => _tanstack_react_query215.UseQueryResult<GetCountOfOffersForCollectibleReturn, Error>;
+//#endregion
+//#region src/react/hooks/useListListingsForCollectible.d.ts
+declare const UseListListingsForCollectibleArgsSchema: z.ZodObject<Omit<{
+  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, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | 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>;
+    }, "strip", z.ZodTypeAny, {
+      order: SortOrder;
+      column: string;
+    }, {
+      order: SortOrder;
+      column: string;
+    }>, "many">>;
+  }, "strip", z.ZodTypeAny, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }, {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  }>>;
+} & {
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodString;
+  collectibleId: z.ZodString;
+}, "tokenId" | "contractAddress">, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      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_query304.OmitKeyof<_tanstack_react_query304.UseQueryOptions<ListCollectibleListingsReturn, Error, ListCollectibleListingsReturn, (SdkConfig | "collectable" | "listings" | {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  page?: {
+    page: number;
+    pageSize: number;
+    sort?: {
+      order: SortOrder;
+      column: string;
+    }[] | undefined;
+    more?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query304.QueryFunction<ListCollectibleListingsReturn, (SdkConfig | "collectable" | "listings" | {
+    chainId: number;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "listings" | {
+    chainId: number;
+    collectionAddress: string;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    page?: {
+      page: number;
+      pageSize: number;
+      sort?: {
+        order: SortOrder;
+        column: string;
+      }[] | undefined;
+      more?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: ListCollectibleListingsReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListListingsForCollectible: (args: UseListListingsForCollectibleArgs) => _tanstack_react_query304.UseQueryResult<ListCollectibleListingsReturn, Error>;
+//#endregion
+//#region src/react/hooks/useCountListingsForCollectible.d.ts
+declare const UseCountListingsForCollectibleArgsSchema: z.ZodObject<Omit<{
+  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, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }, {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  }>>;
+}, "tokenId" | "contractAddress"> & {
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  collectibleId: z.ZodString;
+  chainId: z.ZodNumber;
+  query: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseCountListingsForCollectibleArgs = z.infer<typeof UseCountListingsForCollectibleArgsSchema>;
+type UseCountListingsForCollectibleReturn = Awaited<ReturnType<typeof fetchCountListingsForCollectible>>;
+declare const fetchCountListingsForCollectible: (args: UseCountListingsForCollectibleArgs, config: SdkConfig) => Promise<GetCountOfListingsForCollectibleReturn>;
+declare const countListingsForCollectibleOptions: (args: UseCountListingsForCollectibleArgs, config: SdkConfig) => _tanstack_react_query233.OmitKeyof<_tanstack_react_query233.UseQueryOptions<GetCountOfListingsForCollectibleReturn, Error, GetCountOfListingsForCollectibleReturn, (SdkConfig | "collectable" | "listingsCount" | {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  collectibleId: string;
+  filter?: {
+    marketplace?: MarketplaceKind[] | undefined;
+    currencies?: string[] | undefined;
+    createdBy?: string[] | undefined;
+  } | undefined;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query233.QueryFunction<GetCountOfListingsForCollectibleReturn, (SdkConfig | "collectable" | "listingsCount" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | "listingsCount" | {
+    chainId: number;
+    collectionAddress: `0x${string}`;
+    collectibleId: string;
+    filter?: {
+      marketplace?: MarketplaceKind[] | undefined;
+      currencies?: string[] | undefined;
+      createdBy?: string[] | undefined;
+    } | undefined;
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  })[] & {
+    [dataTagSymbol]: GetCountOfListingsForCollectibleReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCountListingsForCollectible: (args: UseCountListingsForCollectibleArgs) => _tanstack_react_query233.UseQueryResult<GetCountOfListingsForCollectibleReturn, Error>;
+//#endregion
+//#region src/react/hooks/useLowestListing.d.ts
+declare function useLowestListing(args: UseLowestListingArgs): _tanstack_react_query416.UseQueryResult<Order | null | undefined, Error>;
+//#endregion
+//#region src/react/hooks/useMarketplaceConfig.d.ts
+declare const useMarketplaceConfig: () => _tanstack_react_query418.UseQueryResult<MarketplaceConfig, Error>;
+//#endregion
+//#region src/react/hooks/useRoyalty.d.ts
+declare const UseRoyaltySchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+  collectibleId: z.ZodString;
+  query: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  collectionAddress: `0x${string}`;
+  collectibleId: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseRoyaltyArgs = z.infer<typeof UseRoyaltySchema>;
+declare const useRoyalty: (args: UseRoyaltyArgs) => {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  error: viem354.ReadContractErrorType;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: true;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+} | {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  error: null;
+  isError: false;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: false;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+} | {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  error: viem354.ReadContractErrorType;
+  isError: true;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: true;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "error";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+} | {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoading: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+} | {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  error: null;
+  isError: false;
+  isPending: true;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: false;
+  isPlaceholderData: false;
+  status: "pending";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isLoading: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+} | {
+  data: {
+    percentage: bigint;
+    recipient: `0x${string}`;
+  } | null;
+  isError: false;
+  error: null;
+  isPending: false;
+  isLoading: false;
+  isLoadingError: false;
+  isRefetchError: false;
+  isSuccess: true;
+  isPlaceholderData: true;
+  status: "success";
+  dataUpdatedAt: number;
+  errorUpdatedAt: number;
+  failureCount: number;
+  failureReason: viem354.ReadContractErrorType | null;
+  errorUpdateCount: number;
+  isFetched: boolean;
+  isFetchedAfterMount: boolean;
+  isFetching: boolean;
+  isInitialLoading: boolean;
+  isPaused: boolean;
+  isRefetching: boolean;
+  isStale: boolean;
+  refetch: (options?: _tanstack_react_query356.RefetchOptions) => Promise<_tanstack_react_query356.QueryObserverResult<readonly [`0x${string}`, bigint], viem354.ReadContractErrorType>>;
+  fetchStatus: _tanstack_react_query356.FetchStatus;
+  promise: Promise<readonly [`0x${string}`, bigint]>;
+  queryKey: _tanstack_react_query356.QueryKey;
+};
+//#endregion
+//#region src/react/hooks/useGenerateListingTransaction.d.ts
+type UseGenerateListingTransactionArgs = {
+  chainId: number;
+  onSuccess?: (data?: Step[]) => void;
+};
+type CreateReqWithDateExpiry$1 = Omit<CreateReq, 'expiry'> & {
+  expiry: Date;
+};
+type GenerateListingTransactionProps = Omit<GenerateListingTransactionArgs, 'listing'> & {
+  listing: CreateReqWithDateExpiry$1;
+};
+type GenerateListingTransactionArgsWithNumberChainId = Omit<GenerateListingTransactionArgs, 'chainId' | 'listing'> & {
+  chainId: number;
+  listing: CreateReqWithDateExpiry$1;
+};
+declare const generateListingTransaction: (params: GenerateListingTransactionArgsWithNumberChainId, config: SdkConfig) => Promise<Step[]>;
+declare const useGenerateListingTransaction: (params: UseGenerateListingTransactionArgs) => {
+  generateListingTransaction: _tanstack_react_query338.UseMutateFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateListingTransactionAsync: _tanstack_react_query338.UseMutateAsyncFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, 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;
+} | {
+  generateListingTransaction: _tanstack_react_query338.UseMutateFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateListingTransactionAsync: _tanstack_react_query338.UseMutateAsyncFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  variables: Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">;
+  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;
+} | {
+  generateListingTransaction: _tanstack_react_query338.UseMutateFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateListingTransactionAsync: _tanstack_react_query338.UseMutateAsyncFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  error: Error;
+  variables: Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">;
+  isError: true;
+  isIdle: false;
+  isPending: false;
+  isSuccess: false;
+  status: "error";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+} | {
+  generateListingTransaction: _tanstack_react_query338.UseMutateFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateListingTransactionAsync: _tanstack_react_query338.UseMutateAsyncFunction<Step[], Error, Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: Step[];
+  error: null;
+  variables: Omit<GenerateListingTransactionArgsWithNumberChainId, "chainId">;
+  isError: false;
+  isIdle: false;
+  isPending: false;
+  isSuccess: true;
+  status: "success";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+};
+//#endregion
+//#region src/react/hooks/useGenerateOfferTransaction.d.ts
+type UseGenerateOfferTransactionArgs = {
+  chainId: number;
+  onSuccess?: (data?: Step[]) => void;
+};
+type CreateReqWithDateExpiry = Omit<CreateReq, 'expiry'> & {
+  expiry: Date;
+};
+type GenerateOfferTransactionProps = Omit<GenerateOfferTransactionArgs, 'offer'> & {
+  offer: CreateReqWithDateExpiry;
+};
+type GenerateOfferTransactionArgsWithNumberChainId = Omit<GenerateOfferTransactionArgs, 'chainId' | 'offer'> & {
+  chainId: number;
+  offer: CreateReqWithDateExpiry;
+};
+declare const generateOfferTransaction: (params: GenerateOfferTransactionArgsWithNumberChainId, config: SdkConfig, walletKind?: WalletKind) => Promise<Step[]>;
+declare const useGenerateOfferTransaction: (params: UseGenerateOfferTransactionArgs) => {
+  generateOfferTransaction: _tanstack_react_query346.UseMutateFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateOfferTransactionAsync: _tanstack_react_query346.UseMutateAsyncFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, 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;
+} | {
+  generateOfferTransaction: _tanstack_react_query346.UseMutateFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateOfferTransactionAsync: _tanstack_react_query346.UseMutateAsyncFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  variables: Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">;
+  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;
+} | {
+  generateOfferTransaction: _tanstack_react_query346.UseMutateFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateOfferTransactionAsync: _tanstack_react_query346.UseMutateAsyncFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  error: Error;
+  variables: Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">;
+  isError: true;
+  isIdle: false;
+  isPending: false;
+  isSuccess: false;
+  status: "error";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+} | {
+  generateOfferTransaction: _tanstack_react_query346.UseMutateFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateOfferTransactionAsync: _tanstack_react_query346.UseMutateAsyncFunction<Step[], Error, Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: Step[];
+  error: null;
+  variables: Omit<GenerateOfferTransactionArgsWithNumberChainId, "chainId">;
+  isError: false;
+  isIdle: false;
+  isPending: false;
+  isSuccess: true;
+  status: "success";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+};
+//#endregion
+//#region src/react/hooks/useGenerateSellTransaction.d.ts
+declare const UserGeneratSellTransactionArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  onSuccess: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodNativeEnum<typeof StepType>;
+    data: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<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;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      }, {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      }>;
+      types: z.ZodAny;
+      primaryType: z.ZodString;
+      value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    }, {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        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;
+    }>>;
+    method: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }, {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }>, "many">>], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  onSuccess?: ((args_0: {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}, {
+  chainId: number;
+  onSuccess?: ((args_0: {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}>;
+type UseGenerateSellTransactionArgs = z.infer<typeof UserGeneratSellTransactionArgsSchema>;
+type GenerateSellTransactionArgsWithNumberChainId = Omit<GenerateSellTransactionArgs, 'chainId'> & {
+  chainId: number;
+};
+declare const generateSellTransaction: (args: GenerateSellTransactionArgsWithNumberChainId, config: SdkConfig) => Promise<Step[]>;
+declare const useGenerateSellTransaction: (params: UseGenerateSellTransactionArgs) => {
+  generateSellTransaction: _tanstack_react_query399.UseMutateFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateSellTransactionAsync: _tanstack_react_query399.UseMutateAsyncFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, 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_query399.UseMutateFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateSellTransactionAsync: _tanstack_react_query399.UseMutateAsyncFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  variables: Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">;
+  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_query399.UseMutateFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateSellTransactionAsync: _tanstack_react_query399.UseMutateAsyncFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: undefined;
+  error: Error;
+  variables: Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">;
+  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_query399.UseMutateFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  generateSellTransactionAsync: _tanstack_react_query399.UseMutateAsyncFunction<Step[], Error, Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">, unknown>;
+  data: Step[];
+  error: null;
+  variables: Omit<GenerateSellTransactionArgsWithNumberChainId, "chainId">;
+  isError: false;
+  isIdle: false;
+  isPending: false;
+  isSuccess: true;
+  status: "success";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+};
+//#endregion
+//#region src/react/hooks/useGenerateCancelTransaction.d.ts
+type GenerateCancelTransactionArgsWithNumberChainId = Omit<GenerateCancelTransactionArgs, 'chainId'> & {
+  chainId: number;
+};
+declare const UserGenerateCancelTransactionArgsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  onSuccess: z.ZodOptional<z.ZodFunction<z.ZodTuple<[z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodNativeEnum<typeof StepType>;
+    data: z.ZodOptional<z.ZodString>;
+    to: z.ZodOptional<z.ZodString>;
+    value: z.ZodOptional<z.ZodString>;
+    price: z.ZodOptional<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;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      }, {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      }>;
+      types: z.ZodAny;
+      primaryType: z.ZodString;
+      value: z.ZodAny;
+    }, "strip", z.ZodTypeAny, {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    }, {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        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;
+    }>>;
+    method: z.ZodOptional<z.ZodString>;
+    endpoint: z.ZodOptional<z.ZodString>;
+  }, "strip", z.ZodTypeAny, {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }, {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }>, "many">>], z.ZodUnknown>, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  onSuccess?: ((args_0: {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}, {
+  chainId: number;
+  onSuccess?: ((args_0: {
+    id: StepType;
+    to?: string | undefined;
+    value?: string | undefined;
+    data?: string | undefined;
+    method?: string | undefined;
+    price?: string | undefined;
+    signature?: {
+      domain: {
+        version: string;
+        name: string;
+        chainId: number;
+        verifyingContract: string;
+      };
+      primaryType: string;
+      value?: any;
+      types?: any;
+    } | undefined;
+    endpoint?: string | undefined;
+    post?: {
+      method: string;
+      endpoint: string;
+      body?: any;
+    } | undefined;
+  }[] | undefined, ...args: unknown[]) => unknown) | undefined;
+}>;
+type UseGenerateCancelTransactionArgs = z.infer<typeof UserGenerateCancelTransactionArgsSchema>;
+declare const generateCancelTransaction: (args: GenerateCancelTransactionArgsWithNumberChainId, config: SdkConfig) => Promise<Step[]>;
+declare const useGenerateCancelTransaction: (params: UseGenerateCancelTransactionArgs) => {
+  generateCancelTransaction: _tanstack_react_query322.UseMutateFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  generateCancelTransactionAsync: _tanstack_react_query322.UseMutateAsyncFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, 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;
+} | {
+  generateCancelTransaction: _tanstack_react_query322.UseMutateFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  generateCancelTransactionAsync: _tanstack_react_query322.UseMutateAsyncFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  data: undefined;
+  variables: GenerateCancelTransactionArgsWithNumberChainId;
+  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;
+} | {
+  generateCancelTransaction: _tanstack_react_query322.UseMutateFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  generateCancelTransactionAsync: _tanstack_react_query322.UseMutateAsyncFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  data: undefined;
+  error: Error;
+  variables: GenerateCancelTransactionArgsWithNumberChainId;
+  isError: true;
+  isIdle: false;
+  isPending: false;
+  isSuccess: false;
+  status: "error";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+} | {
+  generateCancelTransaction: _tanstack_react_query322.UseMutateFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  generateCancelTransactionAsync: _tanstack_react_query322.UseMutateAsyncFunction<Step[], Error, GenerateCancelTransactionArgsWithNumberChainId, unknown>;
+  data: Step[];
+  error: null;
+  variables: GenerateCancelTransactionArgsWithNumberChainId;
+  isError: false;
+  isIdle: false;
+  isPending: false;
+  isSuccess: true;
+  status: "success";
+  reset: () => void;
+  context: unknown;
+  failureCount: number;
+  failureReason: Error | null;
+  isPaused: boolean;
+  submittedAt: number;
+};
+//#endregion
+//#region src/react/hooks/useTransferTokens.d.ts
+interface BaseTransferParams {
+  chainId: number;
+  collectionAddress: Hex;
+  tokenId: string;
+  receiverAddress: Address;
+}
+interface ERC721TransferParams extends BaseTransferParams {
+  contractType: ContractType.ERC721;
+}
+interface ERC1155TransferParams extends BaseTransferParams {
+  contractType: ContractType.ERC1155;
+  quantity: string;
+}
+type TransferTokensParams = ERC721TransferParams | ERC1155TransferParams;
+declare const useTransferTokens: () => {
+  transferTokensAsync: (params: TransferTokensParams) => Promise<`0x${string}`>;
+  hash: `0x${string}` | undefined;
+  transferring: boolean;
+  transferFailed: boolean;
+  transferSuccess: boolean;
+};
+//#endregion
+//#region src/react/hooks/useCheckoutOptions.d.ts
+declare const UseCheckoutOptionsSchema: z.ZodObject<{
+  chainId: z.ZodNumber;
+  orders: z.ZodArray<z.ZodObject<{
+    collectionAddress: z.ZodEffects<z.ZodString, `0x${string}`, string>;
+    orderId: z.ZodString;
+    marketplace: z.ZodNativeEnum<typeof MarketplaceKind>;
+  }, "strip", z.ZodTypeAny, {
+    collectionAddress: `0x${string}`;
+    marketplace: MarketplaceKind;
+    orderId: string;
+  }, {
+    collectionAddress: string;
+    marketplace: MarketplaceKind;
+    orderId: string;
+  }>, "many">;
+  query: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodBoolean>;
+  }, "strip", z.ZodTypeAny, {
+    enabled?: boolean | undefined;
+  }, {
+    enabled?: boolean | undefined;
+  }>>;
+}, "strip", z.ZodTypeAny, {
+  chainId: number;
+  orders: {
+    collectionAddress: `0x${string}`;
+    marketplace: MarketplaceKind;
+    orderId: string;
+  }[];
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}, {
+  chainId: number;
+  orders: {
+    collectionAddress: string;
+    marketplace: MarketplaceKind;
+    orderId: string;
+  }[];
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+}>;
+type UseCheckoutOptionsArgs = z.infer<typeof UseCheckoutOptionsSchema>;
+type UseCheckoutOptionsReturn = Awaited<ReturnType<typeof fetchCheckoutOptions>>;
+declare const fetchCheckoutOptions: (args: UseCheckoutOptionsArgs & {
+  walletAddress: Hex;
+}, config: SdkConfig) => Promise<CheckoutOptionsMarketplaceReturn>;
+declare const checkoutOptionsOptions: (args: UseCheckoutOptionsArgs & {
+  walletAddress: Hex;
+}, config: SdkConfig) => _tanstack_react_query449.OmitKeyof<_tanstack_react_query449.UseQueryOptions<CheckoutOptionsMarketplaceReturn, Error, CheckoutOptionsMarketplaceReturn, (string | ({
+  chainId: number;
+  orders: {
+    collectionAddress: `0x${string}`;
+    marketplace: MarketplaceKind;
+    orderId: string;
+  }[];
+  query?: {
+    enabled?: boolean | undefined;
+  } | undefined;
+} & {
+  walletAddress: Hex;
+}))[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query449.QueryFunction<CheckoutOptionsMarketplaceReturn, (string | ({
+    chainId: number;
+    orders: {
+      collectionAddress: `0x${string}`;
+      marketplace: MarketplaceKind;
+      orderId: string;
+    }[];
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  } & {
+    walletAddress: Hex;
+  }))[], never> | undefined;
+} & {
+  queryKey: (string | ({
+    chainId: number;
+    orders: {
+      collectionAddress: `0x${string}`;
+      marketplace: MarketplaceKind;
+      orderId: string;
+    }[];
+    query?: {
+      enabled?: boolean | undefined;
+    } | undefined;
+  } & {
+    walletAddress: Hex;
+  }))[] & {
+    [dataTagSymbol]: CheckoutOptionsMarketplaceReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCheckoutOptions: (args: UseCheckoutOptionsArgs) => _tanstack_react_query449.UseQueryResult<CheckoutOptionsMarketplaceReturn, Error>;
+//#endregion
+//#region src/react/hooks/useCheckoutOptionsSalesContract.d.ts
+type UseCheckoutOptionsSalesContractArgs = Omit<CheckoutOptionsSalesContractArgs, 'wallet' | 'chainId'> & {
+  chainId: number;
+};
+declare const checkoutOptionsSalesContractOptions: (args: (UseCheckoutOptionsSalesContractArgs & {
+  wallet?: Hex;
+}) | typeof skipToken, config: SdkConfig) => _tanstack_react_query430.UseQueryOptions<CheckoutOptionsSalesContractReturn, Error, CheckoutOptionsSalesContractReturn, (string | symbol | (Omit<CheckoutOptionsSalesContractArgs, "chainId" | "wallet"> & {
+  chainId: number;
+} & {
+  wallet?: Hex;
+}))[]> & {
+  initialData?: CheckoutOptionsSalesContractReturn | _tanstack_react_query430.InitialDataFunction<CheckoutOptionsSalesContractReturn> | undefined;
+} & {
+  queryKey: (string | symbol | (Omit<CheckoutOptionsSalesContractArgs, "chainId" | "wallet"> & {
+    chainId: number;
+  } & {
+    wallet?: Hex;
+  }))[] & {
+    [dataTagSymbol]: CheckoutOptionsSalesContractReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCheckoutOptionsSalesContract: (args: UseCheckoutOptionsSalesContractArgs | typeof skipToken) => _tanstack_react_query430.UseQueryResult<CheckoutOptionsSalesContractReturn, Error>;
+//#endregion
+//#region src/react/hooks/useListCollections.d.ts
+type UseListCollectionsArgs = {
+  marketplaceType?: MarketplaceType;
+  query?: {
+    enabled?: boolean;
+  };
+};
+declare const useListCollections: (args?: UseListCollectionsArgs) => _tanstack_react_query464.UseQueryResult<({
+  chainId: number;
+  address: string;
+  source: string;
+  name: string;
+  type: string;
+  symbol: string;
+  decimals?: number;
+  logoURI: string;
+  deployed: boolean;
+  bytecodeHash: string;
+  extensions: _0xsequence_metadata456.ContractInfoExtensions;
+  updatedAt: string;
+  queuedAt?: string;
+  status: _0xsequence_metadata456.ResourceStatus;
+  marketplaceType: MarketplaceType;
+  contractType: ContractType;
+  feePercentage: number;
+  destinationMarketplace: OrderbookKind;
+  currencyOptions: Array<string>;
+  bannerUrl: string;
+  itemsAddress: string;
+  filterSettings?: CollectionFilterSettings;
+} | {
+  chainId: number;
+  address: string;
+  source: string;
+  name: string;
+  type: string;
+  symbol: string;
+  decimals?: number;
+  logoURI: string;
+  deployed: boolean;
+  bytecodeHash: string;
+  extensions: _0xsequence_metadata456.ContractInfoExtensions;
+  updatedAt: string;
+  queuedAt?: string;
+  status: _0xsequence_metadata456.ResourceStatus;
+  marketplaceType: MarketplaceType;
+  saleAddress: string;
+  bannerUrl: string;
+  itemsAddress: string;
+  filterSettings?: CollectionFilterSettings;
+})[], Error>;
+//#endregion
+//#region src/react/hooks/useCancelOrder.d.ts
+interface UseCancelOrderArgs {
+  collectionAddress: string;
+  chainId: number;
+  onSuccess?: ({
+    hash,
+    orderId
+  }: {
+    hash?: string;
+    orderId?: string;
+  }) => void;
+  onError?: (error: Error) => void;
+}
+type TransactionStep = {
+  exist: boolean;
+  isExecuting: boolean;
+  execute: () => Promise<void>;
+};
+declare const useCancelOrder: ({
+  collectionAddress,
+  chainId,
+  onSuccess,
+  onError
+}: UseCancelOrderArgs) => {
+  cancelOrder: (params: {
+    orderId: string;
+    marketplace: MarketplaceKind;
+  }) => Promise<void>;
+  isExecuting: boolean;
+  cancellingOrderId: string | null;
+};
+//#endregion
+//#region src/react/hooks/useCollectionDetails.d.ts
+type UseCollectionDetails = {
+  collectionAddress: string;
+  chainId: number;
+  query?: {
+    enabled?: boolean;
+  };
+};
+declare const collectionDetailsOptions: (args: UseCollectionDetails, config: SdkConfig) => _tanstack_react_query439.OmitKeyof<_tanstack_react_query439.UseQueryOptions<Collection, Error, Collection, (string | UseCollectionDetails)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query439.QueryFunction<Collection, (string | UseCollectionDetails)[], never> | undefined;
+} & {
+  queryKey: (string | UseCollectionDetails)[] & {
+    [dataTagSymbol]: Collection;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCollectionDetails: (args: UseCollectionDetails) => _tanstack_react_query439.UseQueryResult<Collection, Error>;
+//#endregion
+//#region src/react/hooks/useCollectionDetailsPolling.d.ts
+type UseCollectionDetailsPolling = {
+  collectionAddress: string;
+  chainId: number;
+};
+declare const collectionDetailsPollingOptions: (args: UseCollectionDetailsPolling, config: SdkConfig) => _tanstack_react_query421.OmitKeyof<_tanstack_react_query421.UseQueryOptions<Collection, Error, Collection, (string | {
+  collectionAddress: string;
+  chainId: number;
+  query?: {
+    enabled?: boolean;
+  };
+})[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query421.QueryFunction<Collection, (string | {
+    collectionAddress: string;
+    chainId: number;
+    query?: {
+      enabled?: boolean;
+    };
+  })[], never> | undefined;
+} & {
+  queryKey: (string | {
+    collectionAddress: string;
+    chainId: number;
+    query?: {
+      enabled?: boolean;
+    };
+  })[] & {
+    [dataTagSymbol]: Collection;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useCollectionDetailsPolling: (args: UseCollectionDetailsPolling) => _tanstack_react_query421.UseQueryResult<Collection, Error>;
+//#endregion
+//#region src/react/hooks/useListTokenMetadata.d.ts
+declare const useListTokenMetadata: (args: FetchTokenMetadataArgs) => _tanstack_react_query482.UseQueryResult<_0xsequence_metadata481.TokenMetadata[], Error>;
+//#endregion
+//#region src/react/hooks/useList1155ShopCardData.d.ts
+interface UseList1155ShopCardDataProps {
+  tokenIds: string[];
+  chainId: number;
+  contractAddress: Address;
+  salesContractAddress: Address;
+  enabled?: boolean;
+}
+declare function useList1155ShopCardData({
+  tokenIds,
+  chainId,
+  contractAddress,
+  salesContractAddress,
+  enabled
+}: UseList1155ShopCardDataProps): {
+  collectibleCards: {
+    collectibleId: string;
+    chainId: number;
+    collectionAddress: Address;
+    collectionType: ContractType.ERC1155;
+    tokenMetadata: TokenMetadata;
+    cardLoading: boolean;
+    salesContractAddress: Address;
+    salePrice: {
+      amount: string;
+      currencyAddress: `0x${string}`;
+    };
+    quantityInitial: string | undefined;
+    quantityDecimals: number | undefined;
+    quantityRemaining: string | undefined;
+    saleStartsAt: string | undefined;
+    saleEndsAt: string | undefined;
+    marketplaceType: "shop";
+  }[];
+  tokenMetadataError: Error | null;
+  tokenSaleDetailsError: Error | null;
+  collectionDetailsError: Error | null;
+  isLoading: boolean;
+};
+//#endregion
+//#region src/react/hooks/useList721ShopCardData.d.ts
+interface UseList721ShopCardDataProps {
+  tokenIds: string[];
+  chainId: number;
+  contractAddress: Address;
+  salesContractAddress: Address;
+  enabled?: boolean;
+}
+declare function useList721ShopCardData({
+  tokenIds,
+  chainId,
+  contractAddress,
+  salesContractAddress,
+  enabled
+}: UseList721ShopCardDataProps): {
+  salePrice: {
+    amount: string;
+    currencyAddress: `0x${string}`;
+  };
+  collectibleCards: {
+    collectibleId: string;
+    chainId: number;
+    collectionAddress: Address;
+    collectionType: ContractType.ERC721;
+    tokenMetadata: TokenMetadata;
+    cardLoading: boolean;
+    salesContractAddress: Address;
+    salePrice: {
+      amount: string;
+      currencyAddress: `0x${string}`;
+    };
+    quantityInitial: string | undefined;
+    quantityDecimals: number | undefined;
+    quantityRemaining: string | undefined;
+    saleStartsAt: string | undefined;
+    saleEndsAt: string | undefined;
+    marketplaceType: "shop";
+  }[];
+  tokenMetadataError: Error | null;
+  saleDetailsError: viem471.ReadContractErrorType | null;
+  collectionDetailsError: Error | null;
+  saleDetails: {
+    supplyCap: bigint;
+    cost: bigint;
+    paymentToken: `0x${string}`;
+    startTime: bigint;
+    endTime: bigint;
+    merkleRoot: `0x${string}`;
+  } | undefined;
+  isLoading: boolean;
+};
+//#endregion
+//#region src/react/hooks/useListMarketCardData.d.ts
+interface UseListMarketCardDataProps {
+  collectionAddress: Address;
+  chainId: number;
+  orderbookKind: OrderbookKind;
+  collectionType: ContractType;
+  filterOptions?: PropertyFilter[];
+  searchText?: string;
+  showListedOnly?: boolean;
+  onCollectibleClick?: (tokenId: string) => void;
+  onCannotPerformAction?: (action: CollectibleCardAction) => void;
+  prioritizeOwnerActions?: boolean;
+  assetSrcPrefixUrl?: string;
+}
+declare function useListMarketCardData({
+  collectionAddress,
+  chainId,
+  orderbookKind,
+  collectionType,
+  filterOptions,
+  searchText,
+  showListedOnly,
+  onCollectibleClick,
+  onCannotPerformAction,
+  prioritizeOwnerActions,
+  assetSrcPrefixUrl
+}: UseListMarketCardDataProps): {
+  collectibleCards: MarketCollectibleCardProps[];
+  isLoading: boolean;
+  error: Error | null;
+  hasNextPage: boolean;
+  isFetchingNextPage: boolean;
+  fetchNextPage: (options?: _tanstack_react_query467.FetchNextPageOptions) => Promise<_tanstack_react_query467.InfiniteQueryObserverResult<_tanstack_react_query467.InfiniteData<ListCollectiblesReturn, unknown>, Error>>;
+  allCollectibles: CollectibleOrder[];
+};
+//#endregion
+//#region src/react/hooks/useGetTokenSuppliesMap.d.ts
+declare const useGetTokenSuppliesMap: ({
+  chainId,
+  tokenIds,
+  collectionAddress,
+  query
+}: {
+  chainId: number;
+  tokenIds: string[];
+  collectionAddress: string;
+  query?: {
+    enabled?: boolean;
+  };
+}) => _tanstack_react_query466.UseQueryResult<_0xsequence_indexer465.GetTokenSuppliesMapReturn, Error>;
+//#endregion
+//#region src/react/hooks/useListPrimarySaleItems.d.ts
+type UseListPrimarySaleItemsArgs = Omit<ListPrimarySaleItemsArgs, 'chainId'> & {
+  chainId: number;
+};
+declare const listPrimarySaleItemsOptions: (args: UseListPrimarySaleItemsArgs, config: SdkConfig) => _tanstack_react_query474.OmitKeyof<_tanstack_react_query474.UseQueryOptions<ListPrimarySaleItemsReturn, Error, ListPrimarySaleItemsReturn, (string | SdkConfig | UseListPrimarySaleItemsArgs)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query474.QueryFunction<ListPrimarySaleItemsReturn, (string | SdkConfig | UseListPrimarySaleItemsArgs)[], never> | undefined;
+} & {
+  queryKey: (string | SdkConfig | UseListPrimarySaleItemsArgs)[] & {
+    [dataTagSymbol]: ListPrimarySaleItemsReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListPrimarySaleItems: (args: UseListPrimarySaleItemsArgs) => _tanstack_react_query474.UseQueryResult<ListPrimarySaleItemsReturn, Error>;
+//#endregion
+//#region src/react/hooks/useERC721SaleMintedTokens.d.ts
+interface UseERC721SaleMintedTokensProps {
+  chainId: number;
+  contractAddress: Address;
+  salesContractAddress: Address;
+  enabled?: boolean;
+  tokenIds: string[];
+}
+declare function useERC721SaleMintedTokens({
+  chainId,
+  contractAddress,
+  salesContractAddress,
+  tokenIds,
+  enabled
+}: UseERC721SaleMintedTokensProps): {
+  ownedCount: number;
+  totalSupplyCap: number;
+  remainingCount: number;
+  isLoading: boolean;
+  error: viem483.ReadContractErrorType | null;
+  saleDetails: {
+    supplyCap: bigint;
+    cost: bigint;
+    paymentToken: `0x${string}`;
+    startTime: bigint;
+    endTime: bigint;
+    merkleRoot: `0x${string}`;
+  } | undefined;
+};
+//#endregion
+export { CollectionBalanceFilter, CreateReqWithDateExpiry$1 as CreateReqWithDateExpiry, GenerateListingTransactionProps, GenerateOfferTransactionProps, TransactionStep, TransferTokensParams, UseCheckoutOptionsArgs, UseCheckoutOptionsReturn, UseCollectibleArgs, UseCollectibleReturn, UseCollectionBalanceDetailsArgs, UseComparePricesReturn, UseContOfCollectableReturn, UseConvertPriceToUSDArgs, UseConvertPriceToUSDReturn, UseCountListingsForCollectibleArgs, UseCountListingsForCollectibleReturn, UseCountOfCollectablesArgs, UseCountOffersForCollectibleArgs, UseCountOffersForCollectibleReturn, UseCurrencyReturn, UseFilterReturn, UseFiltersArgs, UseFloorOrderArgs, UseFloorOrderReturn, UseGenerateListingTransactionArgs, UseGenerateOfferTransactionArgs, UseListCollectibleActivitiesArgs, UseListCollectibleActivitiesReturn, UseListCollectiblesPaginatedArgs, UseListCollectiblesPaginatedReturn, UseListCollectionActivitiesArgs, UseListCollectionActivitiesReturn, UseListListingsForCollectibleReturn, UseListOffersForCollectibleReturn, checkoutOptionsOptions, checkoutOptionsSalesContractOptions, collectibleOptions, collectionBalanceDetailsOptions, collectionDetailsOptions, collectionDetailsPollingOptions, comparePricesOptions, convertPriceToUSD, convertPriceToUSDOptions, countListingsForCollectibleOptions, countOfCollectablesOptions, countOffersForCollectibleOptions, currencyOptions, fetchFilters, filtersOptions, floorOrderOptions, generateCancelTransaction, generateListingTransaction, generateOfferTransaction, generateSellTransaction, listCollectibleActivitiesOptions, listCollectiblesPaginatedOptions, listCollectionActivitiesOptions, listListingsForCollectibleOptions, listOffersForCollectibleOptions, listPrimarySaleItemsOptions, useAutoSelectFeeOption, useBalanceOfCollectible, useCancelOrder, useCheckoutOptions, useCheckoutOptionsSalesContract, useCollectible, useCollectionBalanceDetails, useCollectionDetails, useCollectionDetailsPolling, useComparePrices, useConfig, useConvertPriceToUSD, useCountListingsForCollectible, useCountOfCollectables, useCountOffersForCollectible, useCurrency, useERC721SaleMintedTokens, useFilterState, useFilters, useFiltersProgressive, useFloorOrder, useGenerateCancelTransaction, useGenerateListingTransaction, useGenerateOfferTransaction, useGenerateSellTransaction, useGetTokenSuppliesMap, useHighestOffer, useInventory, useList1155ShopCardData, useList721ShopCardData, useListBalances, useListCollectibleActivities, useListCollectibles, useListCollectiblesPaginated, useListCollectionActivities, useListCollections, useListListingsForCollectible, useListMarketCardData, useListOffersForCollectible, useListPrimarySaleItems, useListTokenMetadata, useLowestListing, useMarketCurrencies, useMarketplaceConfig, useRoyalty, useTransferTokens };
+//# sourceMappingURL=index-BQW0PUkQ.d.ts.map