@0xsequence/marketplace-sdk 0.9.0 → 1.0.0

package/dist/index-CQnGIGb5.d.ts

@@ -0,0 +1,346 @@
+import { Optional, PropertyFilter, PropertyType } from "./create-config-lLSrnkbb.js";
+import { FiltersQueryOptions } from "./filters-B8XS4tFH.js";
+import * as _tanstack_react_query298 from "@tanstack/react-query";
+import { PropertyFilter as PropertyFilter$1 } from "@0xsequence/metadata";
+import * as nuqs0 from "nuqs";
+
+//#region src/react/hooks/ui/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?: nuqs0.Options) => Promise<URLSearchParams>;
+  setSearchText: (value: string | ((old: string) => string | null) | null, options?: nuqs0.Options) => Promise<URLSearchParams>;
+  setShowListedOnly: (value: boolean | ((old: boolean) => boolean | null) | null, options?: nuqs0.Options) => Promise<URLSearchParams>;
+};
+//#endregion
+//#region src/react/hooks/ui/useFilters.d.ts
+type UseFiltersParams = Optional<FiltersQueryOptions, 'config'>;
+/**
+ * Hook to fetch metadata filters for a collection
+ *
+ * Retrieves property filters for a collection from the metadata service,
+ * with support for marketplace-specific filter configuration including
+ * exclusion rules and custom ordering.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address to fetch filters for
+ * @param params.showAllFilters - Whether to show all filters or apply marketplace filtering
+ * @param params.excludePropertyValues - Whether to exclude property values from the response
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing property filters for the collection
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: filters, isLoading } = useFilters({
+ *   chainId: 137,
+ *   collectionAddress: '0x1234...'
+ * })
+ *
+ * if (data) {
+ *   console.log(`Found ${data.length} filters`);
+ *   data.forEach(filter => {
+ *     console.log(`${filter.name}: ${filter.values?.join(', ')}`);
+ *   });
+ * }
+ * ```
+ *
+ * @example
+ * With marketplace filtering disabled:
+ * ```typescript
+ * const { data: allFilters } = useFilters({
+ *   chainId: 1,
+ *   collectionAddress: '0x5678...',
+ *   showAllFilters: true, // Bypass marketplace filter rules
+ *   query: {
+ *     enabled: Boolean(selectedCollection),
+ *     staleTime: 300000 // Cache for 5 minutes
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * Exclude property values for faster loading:
+ * ```typescript
+ * const { data: filterNames } = useFilters({
+ *   chainId: 137,
+ *   collectionAddress: collectionAddress,
+ *   excludePropertyValues: true, // Only get filter names, not values
+ *   query: {
+ *     enabled: Boolean(collectionAddress)
+ *   }
+ * })
+ * ```
+ */
+declare function useFilters(params: UseFiltersParams): _tanstack_react_query298.UseQueryResult<PropertyFilter$1[], Error>;
+/**
+ * Hook to progressively load collection filters
+ *
+ * First loads filter names only for fast initial display, then loads full filter
+ * data with values. Uses placeholder data to provide immediate feedback while
+ * full data loads in the background.
+ *
+ * @param params - Configuration parameters (same as useFilters)
+ *
+ * @returns Query result with additional loading states
+ * @returns result.isLoadingNames - Whether filter names are still loading
+ * @returns result.isFetchingValues - Whether filter values are being fetched
+ *
+ * @example
+ * Progressive filter loading:
+ * ```typescript
+ * const {
+ *   data: filters,
+ *   isLoadingNames,
+ *   isFetchingValues,
+ *   isLoading
+ * } = useFiltersProgressive({
+ *   chainId: 137,
+ *   collectionAddress: '0x1234...'
+ * })
+ *
+ * if (isLoadingNames) {
+ *   return <div>Loading filters...</div>;
+ * }
+ *
+ * return (
+ *   <div>
+ *     {filters?.map(filter => (
+ *       <FilterComponent
+ *         key={filter.name}
+ *         filter={filter}
+ *         isLoadingValues={isFetchingValues}
+ *       />
+ *     ))}
+ *   </div>
+ * );
+ * ```
+ */
+declare function useFiltersProgressive(params: UseFiltersParams): {
+  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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.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;
+  isEnabled: boolean;
+  refetch: (options?: _tanstack_react_query298.RefetchOptions) => Promise<_tanstack_react_query298.QueryObserverResult<PropertyFilter$1[], Error>>;
+  fetchStatus: _tanstack_react_query298.FetchStatus;
+  promise: Promise<PropertyFilter$1[]>;
+};
+type UseFiltersArgs = {
+  chainId: number;
+  collectionAddress: string;
+  showAllFilters?: boolean;
+  excludePropertyValues?: boolean;
+  query?: {
+    enabled?: boolean;
+  };
+};
+type UseFilterReturn = PropertyFilter$1[];
+//#endregion
+//#region src/react/hooks/ui/useOpenConnectModal.d.ts
+declare const useOpenConnectModal: () => {
+  openConnectModal: () => void;
+};
+//#endregion
+export { UseFilterReturn, UseFiltersArgs, UseFiltersParams, useFilterState, useFilters, useFiltersProgressive, useOpenConnectModal };
+//# sourceMappingURL=index-CQnGIGb5.d.ts.map

package/dist/{index-DaE5ZNHb.d.ts → index-CY5UEX4h.d.ts}

@@ -1,4 +1,4 @@
-import { ContractType } from "./new-marketplace-types-Bfis0U4J.js";
+import { ContractType } from "./create-config-lLSrnkbb.js";
 
 //#region src/react/ui/components/marketplace-collectible-card/utils/formatPrice.d.ts
 declare const OVERFLOW_PRICE = 100000000;
@@ -11,14 +11,14 @@ declare const formatPriceNumber: (amount: string, decimals: number) => {
 //#endregion
 //#region src/react/ui/components/marketplace-collectible-card/utils/supplyStatus.d.ts
 declare const getSupplyStatusText: ({
-  quantityInitial,
   quantityRemaining,
-  collectionType
+  collectionType,
+  unlimitedSupply
 }: {
-  quantityInitial: string | undefined;
   quantityRemaining: string | undefined;
   collectionType: ContractType;
+  unlimitedSupply?: boolean;
 }) => string;
 //#endregion
 export { OVERFLOW_PRICE, UNDERFLOW_PRICE, formatPriceNumber, getSupplyStatusText };
-//# sourceMappingURL=index-DaE5ZNHb.d.ts.map
+//# sourceMappingURL=index-CY5UEX4h.d.ts.map

package/dist/{index-DXMfTZ1F.d.ts → index-ChSKFOMx.d.ts}

@@ -4,4 +4,4 @@ declare const SEQUENCE_MARKET_V2_ADDRESS = "0xfdb42A198a932C8D3B506Ffa5e855bC4b3
 declare const DEFAULT_MARKETPLACE_FEE_PERCENTAGE = 2.5;
 //#endregion
 export { DEFAULT_MARKETPLACE_FEE_PERCENTAGE, SEQUENCE_MARKET_V1_ADDRESS, SEQUENCE_MARKET_V2_ADDRESS };
-//# sourceMappingURL=index-DXMfTZ1F.d.ts.map
+//# sourceMappingURL=index-ChSKFOMx.d.ts.map

package/dist/{index-D5v5iluA.d.ts → index-CtF7EE2z.d.ts}

@@ -806,4 +806,4 @@ declare const SequenceMarketplaceV2_ABI: ({
 })[];
 //#endregion
 export { EIP2981_ABI, SequenceMarketplaceV1_ABI, SequenceMarketplaceV2_ABI };
-//# sourceMappingURL=index-D5v5iluA.d.ts.map
+//# sourceMappingURL=index-CtF7EE2z.d.ts.map

package/dist/index-D2HohSwO.d.ts

@@ -0,0 +1,293 @@
+import { CollectibleOrder, ListCollectibleListingsReturn, ListCollectibleOffersReturn, Optional, Order, OrderFilter, Page, SdkConfig } from "./create-config-lLSrnkbb.js";
+import { CountListingsForCollectibleQueryOptions, CountOffersForCollectibleQueryOptions, FloorOrderQueryOptions, HighestOfferQueryOptions, ListListingsForCollectibleQueryOptions, LowestListingQueryOptions, fetchListListingsForCollectible } from "./lowestListing-BQHfQpfg.js";
+import * as _tanstack_react_query2 from "@tanstack/react-query";
+
+//#region src/react/hooks/data/orders/useCountListingsForCollectible.d.ts
+type UseCountListingsForCollectibleParams = Optional<CountListingsForCollectibleQueryOptions, 'config'>;
+/**
+ * Hook to get the count of listings for a specific collectible
+ *
+ * Counts the number of active listings for a given collectible in the marketplace.
+ * Useful for displaying listing counts in UI components.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.collectibleId - The specific collectible/token ID
+ * @param params.filter - Optional filter criteria for listings
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of listings
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: listingCount, isLoading } = useCountListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With filter:
+ * ```typescript
+ * const { data: filteredCount } = useCountListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123',
+ *   filter: { priceRange: { min: '1000000000000000000' } }
+ * })
+ * ```
+ */
+declare function useCountListingsForCollectible(params: UseCountListingsForCollectibleParams): _tanstack_react_query2.UseQueryResult<number, Error>;
+//#endregion
+//#region src/react/hooks/data/orders/useCountOffersForCollectible.d.ts
+type UseCountOffersForCollectibleParams = Optional<CountOffersForCollectibleQueryOptions, 'config'>;
+/**
+ * Hook to get the count of offers for a specific collectible
+ *
+ * Counts the number of active offers for a given collectible in the marketplace.
+ * Useful for displaying offer counts in UI components.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.collectibleId - The specific collectible/token ID
+ * @param params.filter - Optional filter criteria for offers
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the count of offers
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data: offerCount, isLoading } = useCountOffersForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With filter:
+ * ```typescript
+ * const { data: filteredCount } = useCountOffersForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123',
+ *   filter: { priceRange: { min: '1000000000000000000' } }
+ * })
+ * ```
+ */
+declare function useCountOffersForCollectible(params: UseCountOffersForCollectibleParams): _tanstack_react_query2.UseQueryResult<number, Error>;
+//#endregion
+//#region src/react/hooks/data/orders/useFloorOrder.d.ts
+type UseFloorOrderParams = Optional<FloorOrderQueryOptions, 'config'>;
+/**
+ * Hook to fetch the floor order for a collection
+ *
+ * Retrieves the lowest priced order (listing) currently available for any token
+ * in the specified collection from the marketplace.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.filter - Optional filter criteria for collectibles
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the floor order data for the collection
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useFloorOrder({
+ *   chainId: 137,
+ *   collectionAddress: '0x...'
+ * })
+ * ```
+ *
+ * @example
+ * With filters and custom query options:
+ * ```typescript
+ * const { data, isLoading } = useFloorOrder({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   filter: {
+ *     minPrice: '1000000000000000000' // 1 ETH in wei
+ *   },
+ *   query: {
+ *     refetchInterval: 30000,
+ *     enabled: hasCollectionAddress
+ *   }
+ * })
+ * ```
+ */
+declare function useFloorOrder(params: UseFloorOrderParams): _tanstack_react_query2.UseQueryResult<CollectibleOrder, Error>;
+//#endregion
+//#region src/react/hooks/data/orders/useHighestOffer.d.ts
+type UseHighestOfferParams = Optional<HighestOfferQueryOptions, 'config'>;
+/**
+ * Hook to fetch the highest offer for a collectible
+ *
+ * Retrieves the highest offer currently available for a specific token
+ * in a collection from the marketplace.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.tokenId - The token ID within the collection
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the highest offer data or null if no offers exist
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useHighestOffer({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '1'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useHighestOffer({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     refetchInterval: 15000,
+ *     enabled: hasTokenId
+ *   }
+ * })
+ * ```
+ */
+declare function useHighestOffer(params: UseHighestOfferParams): _tanstack_react_query2.UseQueryResult<Order | null, Error>;
+//#endregion
+//#region src/react/hooks/data/orders/useListListingsForCollectible.d.ts
+type UseListListingsForCollectibleParams = Optional<ListListingsForCollectibleQueryOptions, 'config'>;
+/**
+ * Hook to fetch listings for a specific collectible
+ *
+ * Fetches active listings (sales) for a specific token from the marketplace
+ * with support for filtering and pagination.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.collectibleId - The specific token ID to fetch listings for
+ * @param params.filter - Optional filtering parameters (marketplace, currencies, etc.)
+ * @param params.page - Optional pagination parameters
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing listings data for the collectible
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useListListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '123'
+ * })
+ * ```
+ *
+ * @example
+ * With pagination:
+ * ```typescript
+ * const { data } = useListListingsForCollectible({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '456',
+ *   page: {
+ *     page: 2,
+ *     pageSize: 20
+ *   }
+ * })
+ * ```
+ *
+ * @example
+ * With filtering:
+ * ```typescript
+ * const { data } = useListListingsForCollectible({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   collectibleId: '789',
+ *   filter: {
+ *     marketplace: [MarketplaceKind.sequence_marketplace_v2],
+ *     currencies: ['0x...'] // Specific currency addresses
+ *   }
+ * })
+ * ```
+ */
+declare function useListListingsForCollectible(params: UseListListingsForCollectibleParams): _tanstack_react_query2.UseQueryResult<ListCollectibleListingsReturn, Error>;
+type UseListListingsForCollectibleArgs = UseListListingsForCollectibleParams;
+type UseListListingsForCollectibleReturn = Awaited<ReturnType<typeof fetchListListingsForCollectible>>;
+//#endregion
+//#region src/react/hooks/data/orders/useListOffersForCollectible.d.ts
+interface UseListOffersForCollectibleArgs {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  filter?: OrderFilter;
+  page?: Page;
+}
+type UseListOffersForCollectibleReturn = Awaited<ReturnType<typeof fetchListOffersForCollectible>>;
+declare const fetchListOffersForCollectible: (config: SdkConfig, args: UseListOffersForCollectibleArgs) => Promise<ListCollectibleOffersReturn>;
+declare const listOffersForCollectibleOptions: (args: UseListOffersForCollectibleArgs, config: SdkConfig) => _tanstack_react_query2.OmitKeyof<_tanstack_react_query2.UseQueryOptions<ListCollectibleOffersReturn, Error, ListCollectibleOffersReturn, (SdkConfig | "collectable" | UseListOffersForCollectibleArgs | "offers")[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query2.QueryFunction<ListCollectibleOffersReturn, (SdkConfig | "collectable" | UseListOffersForCollectibleArgs | "offers")[], never> | undefined;
+} & {
+  queryKey: (SdkConfig | "collectable" | UseListOffersForCollectibleArgs | "offers")[] & {
+    [dataTagSymbol]: ListCollectibleOffersReturn;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+declare const useListOffersForCollectible: (args: UseListOffersForCollectibleArgs) => _tanstack_react_query2.UseQueryResult<ListCollectibleOffersReturn, Error>;
+//#endregion
+//#region src/react/hooks/data/orders/useLowestListing.d.ts
+type UseLowestListingParams = Optional<LowestListingQueryOptions, 'config'>;
+/**
+ * Hook to fetch the lowest listing for a collectible
+ *
+ * Retrieves the lowest priced listing currently available for a specific token
+ * in a collection from the marketplace.
+ *
+ * @param params - Configuration parameters
+ * @param params.chainId - The chain ID (must be number, e.g., 1 for Ethereum, 137 for Polygon)
+ * @param params.collectionAddress - The collection contract address
+ * @param params.tokenId - The token ID within the collection
+ * @param params.query - Optional React Query configuration
+ *
+ * @returns Query result containing the lowest listing data or null if no listings exist
+ *
+ * @example
+ * Basic usage:
+ * ```typescript
+ * const { data, isLoading } = useLowestListing({
+ *   chainId: 137,
+ *   collectionAddress: '0x...',
+ *   tokenId: '1'
+ * })
+ * ```
+ *
+ * @example
+ * With custom query options:
+ * ```typescript
+ * const { data, isLoading } = useLowestListing({
+ *   chainId: 1,
+ *   collectionAddress: '0x...',
+ *   tokenId: '42',
+ *   query: {
+ *     refetchInterval: 15000,
+ *     enabled: hasTokenId
+ *   }
+ * })
+ * ```
+ */
+declare function useLowestListing(params: UseLowestListingParams): _tanstack_react_query2.UseQueryResult<Order | null | undefined, Error>;
+//#endregion
+export { UseCountListingsForCollectibleParams, UseCountOffersForCollectibleParams, UseFloorOrderParams, UseHighestOfferParams, UseListListingsForCollectibleArgs, UseListListingsForCollectibleParams, UseListListingsForCollectibleReturn, UseListOffersForCollectibleReturn, UseLowestListingParams, listOffersForCollectibleOptions, useCountListingsForCollectible, useCountOffersForCollectible, useFloorOrder, useHighestOffer, useListListingsForCollectible, useListOffersForCollectible, useLowestListing };
+//# sourceMappingURL=index-D2HohSwO.d.ts.map