@0xsequence/marketplace-sdk 0.8.11 → 0.9.0

package/dist/index-DPNWNa7t.d.ts

@@ -0,0 +1,414 @@
+import { CollectibleOrder, Collection, ContractType, CurrencyStatus, GetCollectibleHighestOfferArgs, GetCollectibleLowestListingArgs, GetCollectibleLowestListingReturn, GetCollectionDetailArgs, GetCountOfPrimarySaleItemsArgs, GetFloorOrderArgs, ListCollectiblesArgs, ListCollectiblesReturn, MarketplaceConfig, MarketplaceType, Order, Page, PrimarySaleItemsFilter, SdkConfig } from "./new-marketplace-types-Bfis0U4J.js";
+import { ValuesOptional } from "./index-BUVWziLP.js";
+import * as _tanstack_react_query27 from "@tanstack/react-query";
+import { UseQueryParameters } from "wagmi/query";
+import * as _0xsequence_indexer24 from "@0xsequence/indexer";
+import { ContractInfo, GetTokenBalancesReturn, Page as Page$1 } from "@0xsequence/indexer";
+import * as _0xsequence_metadata32 from "@0xsequence/metadata";
+import { GetTokenMetadataArgs } from "@0xsequence/metadata";
+import { Address, Hex } from "viem";
+
+//#region src/react/queries/balanceOfCollectible.d.ts
+type UseBalanceOfCollectibleArgs = {
+  collectionAddress: Hex;
+  collectableId: string;
+  userAddress: Hex | undefined;
+  chainId: number;
+  isLaos721?: boolean;
+  query?: UseQueryParameters;
+};
+/**
+ * Fetches the balance of a specific collectible for a user
+ *
+ * @param args - Arguments for the API call
+ * @param config - SDK configuration
+ * @returns The balance data
+ */
+declare function fetchBalanceOfCollectible(args: Omit<UseBalanceOfCollectibleArgs, 'userAddress'> & {
+  userAddress: Hex;
+}, config: SdkConfig): Promise<_0xsequence_indexer24.TokenBalance>;
+/**
+ * Creates a tanstack query options object for the balance query
+ *
+ * @param args - The query arguments
+ * @param config - SDK configuration
+ * @returns Query options configuration
+ */
+declare function balanceOfCollectibleOptions(args: UseBalanceOfCollectibleArgs, config: SdkConfig): _tanstack_react_query27.UseQueryOptions<_0xsequence_indexer24.TokenBalance, Error, _0xsequence_indexer24.TokenBalance, (UseBalanceOfCollectibleArgs | "collectable" | "details" | "userBalances")[]> & {
+  initialData?: _0xsequence_indexer24.TokenBalance | _tanstack_react_query27.InitialDataFunction<_0xsequence_indexer24.TokenBalance> | undefined;
+} & {
+  queryKey: (UseBalanceOfCollectibleArgs | "collectable" | "details" | "userBalances")[] & {
+    [dataTagSymbol]: _0xsequence_indexer24.TokenBalance;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/types/query.d.ts
+/**
+ * Standard query options that can be used across all marketplace SDK hooks
+ *
+ * Based on TanStack Query v5 UseQueryOptions, but simplified, the type from TanStack is hard to modify
+ */
+interface StandardQueryOptions<TError = Error> {
+  /** Whether the query should be enabled/disabled */
+  enabled?: boolean;
+  /** Time in milliseconds that  data is considered fresh */
+  staleTime?: number;
+  gcTime?: number;
+  refetchInterval?: number | false | ((query: any) => number | false);
+  refetchOnWindowFocus?: boolean;
+  refetchOnMount?: boolean;
+  refetchOnReconnect?: boolean;
+  retry?: boolean | number | ((failureCount: number, error: TError) => boolean);
+  retryDelay?: number | ((retryAttempt: number, error: TError) => number);
+  suspense?: boolean;
+}
+/**
+ * Standard infinite query options that can be used across all marketplace SDK hooks
+ * that support infinite pagination
+ */
+interface StandardInfiniteQueryOptions<TError = Error> extends StandardQueryOptions<TError> {
+  /** Maximum number of pages to fetch */
+  maxPages?: number;
+}
+//#endregion
+//#region src/react/queries/collectible.d.ts
+interface FetchCollectibleParams extends Omit<GetTokenMetadataArgs, 'chainID' | 'contractAddress' | 'tokenIDs'> {
+  chainId: number;
+  collectionAddress: string;
+  collectibleId: string;
+  config: SdkConfig;
+}
+/**
+ * Fetches collectible metadata from the metadata API
+ */
+declare function fetchCollectible(params: FetchCollectibleParams): Promise<_0xsequence_metadata32.TokenMetadata>;
+type CollectibleQueryOptions = ValuesOptional<FetchCollectibleParams> & {
+  query?: StandardQueryOptions;
+};
+declare function collectibleQueryOptions(params: CollectibleQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<_0xsequence_metadata32.TokenMetadata, Error, _0xsequence_metadata32.TokenMetadata, ("collectable" | "details" | CollectibleQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<_0xsequence_metadata32.TokenMetadata, ("collectable" | "details" | CollectibleQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("collectable" | "details" | CollectibleQueryOptions)[] & {
+    [dataTagSymbol]: _0xsequence_metadata32.TokenMetadata;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/collectionDetails.d.ts
+interface FetchCollectionDetailsParams extends Omit<GetCollectionDetailArgs, 'chainId' | 'contractAddress'> {
+  chainId: number;
+  collectionAddress: string;
+  config: SdkConfig;
+}
+/**
+ * Fetches collection details from the marketplace API
+ */
+declare function fetchCollectionDetails(params: FetchCollectionDetailsParams): Promise<Collection>;
+type CollectionDetailsQueryOptions = ValuesOptional<FetchCollectionDetailsParams> & {
+  query?: StandardQueryOptions;
+};
+declare function collectionDetailsQueryOptions(params: CollectionDetailsQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<Collection, Error, Collection, ("collections" | "detail" | CollectionDetailsQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<Collection, ("collections" | "detail" | CollectionDetailsQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("collections" | "detail" | CollectionDetailsQueryOptions)[] & {
+    [dataTagSymbol]: Collection;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/countOfPrimarySaleItems.d.ts
+interface UseCountOfPrimarySaleItemsArgs extends Omit<GetCountOfPrimarySaleItemsArgs, 'chainId' | 'primarySaleContractAddress'> {
+  chainId: number;
+  primarySaleContractAddress: Address;
+  filter?: PrimarySaleItemsFilter;
+  query?: {
+    enabled?: boolean;
+  };
+}
+declare function fetchCountOfPrimarySaleItems(args: UseCountOfPrimarySaleItemsArgs, config: SdkConfig): Promise<number>;
+declare function countOfPrimarySaleItemsOptions(args: UseCountOfPrimarySaleItemsArgs, config: SdkConfig): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<number, Error, number, (string | UseCountOfPrimarySaleItemsArgs)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<number, (string | UseCountOfPrimarySaleItemsArgs)[], never> | undefined;
+} & {
+  queryKey: (string | UseCountOfPrimarySaleItemsArgs)[] & {
+    [dataTagSymbol]: number;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/floorOrder.d.ts
+interface FetchFloorOrderParams extends Omit<GetFloorOrderArgs, 'contractAddress' | 'chainId'> {
+  collectionAddress: string;
+  chainId: number;
+  config: SdkConfig;
+}
+/**
+ * Fetches the floor order for a collection from the marketplace API
+ */
+declare function fetchFloorOrder(params: FetchFloorOrderParams): Promise<CollectibleOrder>;
+type FloorOrderQueryOptions = ValuesOptional<FetchFloorOrderParams> & {
+  query?: StandardQueryOptions;
+};
+declare function floorOrderQueryOptions(params: FloorOrderQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<CollectibleOrder, Error, CollectibleOrder, ("collectable" | "floorOrders" | FloorOrderQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<CollectibleOrder, ("collectable" | "floorOrders" | FloorOrderQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("collectable" | "floorOrders" | FloorOrderQueryOptions)[] & {
+    [dataTagSymbol]: CollectibleOrder;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/highestOffer.d.ts
+interface FetchHighestOfferParams extends Omit<GetCollectibleHighestOfferArgs, 'contractAddress' | 'chainId'> {
+  collectionAddress: string;
+  chainId: number;
+  config: SdkConfig;
+}
+/**
+ * Fetches the highest offer for a collectible from the marketplace API
+ */
+declare function fetchHighestOffer(params: FetchHighestOfferParams): Promise<Order | null>;
+type HighestOfferQueryOptions = ValuesOptional<FetchHighestOfferParams> & {
+  query?: StandardQueryOptions;
+};
+declare function highestOfferQueryOptions(params: HighestOfferQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<Order | null, Error, Order | null, ("collectable" | "details" | "highestOffers" | HighestOfferQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<Order | null, ("collectable" | "details" | "highestOffers" | HighestOfferQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("collectable" | "details" | "highestOffers" | HighestOfferQueryOptions)[] & {
+    [dataTagSymbol]: Order | null;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/inventory.d.ts
+interface UseInventoryArgs {
+  accountAddress: Address;
+  collectionAddress: Address;
+  chainId: number;
+  isLaos721?: boolean;
+  query?: {
+    enabled?: boolean;
+  };
+}
+interface GetInventoryArgs extends Omit<UseInventoryArgs, 'query'> {
+  isLaos721: boolean;
+}
+interface CollectibleWithBalance extends CollectibleOrder {
+  balance: string;
+  contractInfo?: ContractInfo;
+  contractType: ContractType.ERC1155 | ContractType.ERC721;
+}
+interface CollectiblesResponse {
+  collectibles: CollectibleWithBalance[];
+  page: Page;
+}
+declare function fetchInventory(args: GetInventoryArgs, config: SdkConfig, page: Page): Promise<CollectiblesResponse>;
+declare function inventoryOptions(args: UseInventoryArgs, config: SdkConfig): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseInfiniteQueryOptions<CollectiblesResponse, Error, _tanstack_react_query27.InfiniteData<CollectiblesResponse, unknown>, (string | number)[], Page>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<CollectiblesResponse, (string | number)[], Page> | undefined;
+} & {
+  queryKey: (string | number)[] & {
+    [dataTagSymbol]: _tanstack_react_query27.InfiniteData<CollectiblesResponse, unknown>;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/listBalances.d.ts
+type UseListBalancesArgs = {
+  chainId: number;
+  accountAddress?: Hex;
+  contractAddress?: Hex;
+  tokenId?: string;
+  includeMetadata?: boolean;
+  metadataOptions?: {
+    verifiedOnly?: boolean;
+    unverifiedOnly?: boolean;
+    includeContracts?: Hex[];
+  };
+  includeCollectionTokens?: boolean;
+  page?: Page$1;
+  isLaos721?: boolean;
+  query?: {
+    enabled?: boolean;
+  };
+};
+declare function fetchBalances(args: UseListBalancesArgs, config: SdkConfig, page: Page$1): Promise<GetTokenBalancesReturn>;
+/**
+ * Creates a tanstack infinite query options object for the balances query
+ *
+ * @param args - The query arguments
+ * @param config - SDK configuration
+ * @returns Query options configuration
+ */
+declare function listBalancesOptions(args: UseListBalancesArgs, config: SdkConfig): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseInfiniteQueryOptions<GetTokenBalancesReturn, Error, _tanstack_react_query27.InfiniteData<GetTokenBalancesReturn, unknown>, (SdkConfig | UseListBalancesArgs | "balances" | "tokenBalances")[], any>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<GetTokenBalancesReturn, (SdkConfig | UseListBalancesArgs | "balances" | "tokenBalances")[], any> | undefined;
+} & {
+  queryKey: (SdkConfig | UseListBalancesArgs | "balances" | "tokenBalances")[] & {
+    [dataTagSymbol]: _tanstack_react_query27.InfiniteData<GetTokenBalancesReturn, unknown>;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/listCollectibles.d.ts
+interface FetchListCollectiblesParams extends Omit<ListCollectiblesArgs, 'chainId' | 'contractAddress'> {
+  chainId: number;
+  collectionAddress: Address;
+  isLaos721?: boolean;
+  marketplaceType?: MarketplaceType;
+  config: SdkConfig;
+}
+/**
+ * Fetches a list of collectibles with pagination support from the Marketplace API
+ */
+declare function fetchListCollectibles(params: FetchListCollectiblesParams, marketplaceConfig: MarketplaceConfig, page: Page): Promise<ListCollectiblesReturn>;
+type ListCollectiblesQueryOptions = ValuesOptional<FetchListCollectiblesParams> & {
+  query?: StandardInfiniteQueryOptions;
+};
+declare function listCollectiblesQueryOptions(params: ListCollectiblesQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseInfiniteQueryOptions<ListCollectiblesReturn, Error, _tanstack_react_query27.InfiniteData<ListCollectiblesReturn, unknown>, ("collectable" | "list" | ListCollectiblesQueryOptions)[], Page>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<ListCollectiblesReturn, ("collectable" | "list" | ListCollectiblesQueryOptions)[], Page> | undefined;
+} & {
+  queryKey: ("collectable" | "list" | ListCollectiblesQueryOptions)[] & {
+    [dataTagSymbol]: _tanstack_react_query27.InfiniteData<ListCollectiblesReturn, unknown>;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/listTokenMetadata.d.ts
+interface FetchListTokenMetadataParams {
+  chainId: number;
+  contractAddress: string;
+  tokenIds: string[];
+  config: SdkConfig;
+}
+/**
+ * Fetches token metadata from the metadata API
+ */
+declare function fetchListTokenMetadata(params: FetchListTokenMetadataParams): Promise<_0xsequence_metadata32.TokenMetadata[]>;
+type ListTokenMetadataQueryOptions = ValuesOptional<FetchListTokenMetadataParams> & {
+  query?: StandardQueryOptions;
+};
+declare function listTokenMetadataQueryOptions(params: ListTokenMetadataQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<_0xsequence_metadata32.TokenMetadata[], Error, _0xsequence_metadata32.TokenMetadata[], ("metadata" | "tokenMetadata" | ListTokenMetadataQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<_0xsequence_metadata32.TokenMetadata[], ("metadata" | "tokenMetadata" | ListTokenMetadataQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("metadata" | "tokenMetadata" | ListTokenMetadataQueryOptions)[] & {
+    [dataTagSymbol]: _0xsequence_metadata32.TokenMetadata[];
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/lowestListing.d.ts
+interface FetchLowestListingParams extends Omit<GetCollectibleLowestListingArgs, 'contractAddress' | 'chainId'> {
+  collectionAddress: string;
+  chainId: number;
+  config: SdkConfig;
+}
+/**
+ * Fetches the lowest listing for a collectible from the marketplace API
+ */
+declare function fetchLowestListing(params: FetchLowestListingParams): Promise<GetCollectibleLowestListingReturn['order'] | null>;
+type LowestListingQueryOptions = ValuesOptional<FetchLowestListingParams> & {
+  query?: StandardQueryOptions;
+};
+declare function lowestListingQueryOptions(params: LowestListingQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<Order | null | undefined, Error, Order | null | undefined, ("collectable" | "details" | "lowestListings" | LowestListingQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<Order | null | undefined, ("collectable" | "details" | "lowestListings" | LowestListingQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("collectable" | "details" | "lowestListings" | LowestListingQueryOptions)[] & {
+    [dataTagSymbol]: Order | null | undefined;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+//#region src/react/queries/marketCurrencies.d.ts
+interface FetchMarketCurrenciesParams {
+  chainId: number;
+  includeNativeCurrency?: boolean;
+  collectionAddress?: Address;
+  config: SdkConfig;
+}
+/**
+ * Fetches supported currencies for a marketplace
+ */
+declare function fetchMarketCurrencies(params: FetchMarketCurrenciesParams): Promise<{
+  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;
+}[]>;
+type MarketCurrenciesQueryOptions = ValuesOptional<FetchMarketCurrenciesParams> & {
+  query?: StandardQueryOptions;
+};
+declare function marketCurrenciesQueryOptions(params: MarketCurrenciesQueryOptions): _tanstack_react_query27.OmitKeyof<_tanstack_react_query27.UseQueryOptions<{
+  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, {
+  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;
+}[], ("list" | "currencies" | MarketCurrenciesQueryOptions)[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query27.QueryFunction<{
+    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;
+  }[], ("list" | "currencies" | MarketCurrenciesQueryOptions)[], never> | undefined;
+} & {
+  queryKey: ("list" | "currencies" | MarketCurrenciesQueryOptions)[] & {
+    [dataTagSymbol]: {
+      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;
+    }[];
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+export { CollectibleQueryOptions, CollectiblesResponse, CollectionDetailsQueryOptions, FetchCollectibleParams, FetchCollectionDetailsParams, FetchFloorOrderParams, FetchHighestOfferParams, FetchListCollectiblesParams, FetchListTokenMetadataParams, FetchLowestListingParams, FetchMarketCurrenciesParams, FloorOrderQueryOptions, HighestOfferQueryOptions, ListCollectiblesQueryOptions, ListTokenMetadataQueryOptions, LowestListingQueryOptions, MarketCurrenciesQueryOptions, StandardInfiniteQueryOptions, StandardQueryOptions, UseBalanceOfCollectibleArgs, UseCountOfPrimarySaleItemsArgs, UseInventoryArgs, UseListBalancesArgs, balanceOfCollectibleOptions, collectibleQueryOptions, collectionDetailsQueryOptions, countOfPrimarySaleItemsOptions, fetchBalanceOfCollectible, fetchBalances, fetchCollectible, fetchCollectionDetails, fetchCountOfPrimarySaleItems, fetchFloorOrder, fetchHighestOffer, fetchInventory, fetchListCollectibles, fetchListTokenMetadata, fetchLowestListing, fetchMarketCurrencies, floorOrderQueryOptions, highestOfferQueryOptions, inventoryOptions, listBalancesOptions, listCollectiblesQueryOptions, listTokenMetadataQueryOptions, lowestListingQueryOptions, marketCurrenciesQueryOptions };
+//# sourceMappingURL=index-DPNWNa7t.d.ts.map

package/dist/index-DXMfTZ1F.d.ts

@@ -0,0 +1,7 @@
+//#region src/consts.d.ts
+declare const SEQUENCE_MARKET_V1_ADDRESS = "0xB537a160472183f2150d42EB1c3DD6684A55f74c";
+declare const SEQUENCE_MARKET_V2_ADDRESS = "0xfdb42A198a932C8D3B506Ffa5e855bC4b348a712";
+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

package/dist/index-DaE5ZNHb.d.ts

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

package/dist/index-DsfCs3-x.d.ts

@@ -0,0 +1,122 @@
+import { Env, Marketplace, SdkConfig } from "./new-marketplace-types-Bfis0U4J.js";
+import { BuilderAPI } from "./builder-api-C_zj5mr3.js";
+import { QueryClient } from "@tanstack/react-query";
+import { SequenceAPIClient } from "@0xsequence/api";
+import { GetTokenBalancesReturn, GetTokenSuppliesReturn, SequenceIndexer } from "@0xsequence/indexer";
+import { SequenceMetadata } from "@0xsequence/metadata";
+
+//#region src/react/_internal/api/get-query-client.d.ts
+declare function getQueryClient(): QueryClient;
+//#endregion
+//#region src/react/_internal/api/laos-api.d.ts
+type SortOption = {
+  column: string;
+  order: 'ASC' | 'DESC';
+};
+type PaginationOptions = {
+  sort: SortOption[];
+};
+type TokenSuppliesParams = {
+  chainId: string;
+  contractAddress: string;
+  includeMetadata?: boolean;
+  page?: PaginationOptions;
+};
+type TokenBalancesParams = {
+  chainId: string;
+  accountAddress: string;
+  includeMetadata?: boolean;
+  page?: PaginationOptions;
+};
+declare class LaosAPI {
+  private baseUrl;
+  constructor(baseUrl?: string);
+  getTokenSupplies({
+    chainId,
+    contractAddress,
+    includeMetadata,
+    page
+  }: TokenSuppliesParams): Promise<GetTokenSuppliesReturn>;
+  getTokenBalances({
+    chainId,
+    accountAddress,
+    includeMetadata,
+    page
+  }: TokenBalancesParams): Promise<GetTokenBalancesReturn>;
+}
+//#endregion
+//#region src/react/_internal/api/marketplace-api.d.ts
+declare class SequenceMarketplace extends Marketplace {
+  projectAccessKey: string;
+  jwtAuth?: string | undefined;
+  constructor(hostname: string, projectAccessKey: string, jwtAuth?: string | undefined);
+  _fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+}
+//#endregion
+//#region src/react/_internal/api/query-keys.d.ts
+declare class CollectableKeys {
+  static all: readonly ["collectable"];
+  static details: readonly ["collectable", "details"];
+  static lists: readonly ["collectable", "list"];
+  static floorOrders: readonly ["collectable", "floorOrders"];
+  static userBalances: readonly ["collectable", "collectable", "details", "userBalances"];
+  static royaltyPercentage: readonly ["collectable", "royaltyPercentage"];
+  static highestOffers: readonly ["collectable", "collectable", "details", "highestOffers"];
+  static lowestListings: readonly ["collectable", "collectable", "details", "lowestListings"];
+  static offers: readonly ["collectable", "offers"];
+  static offersCount: readonly ["collectable", "offersCount"];
+  static listings: readonly ["collectable", "listings"];
+  static listingsCount: readonly ["collectable", "listingsCount"];
+  static filter: readonly ["collectable", "filter"];
+  static counts: readonly ["collectable", "counts"];
+  static collectibleActivities: readonly ["collectable", "collectibleActivities"];
+}
+declare class CollectionKeys {
+  static all: readonly ["collections"];
+  static list: readonly ["collections", "list"];
+  static detail: readonly ["collections", "detail"];
+  static collectionActivities: readonly ["collections", "collectionActivities"];
+}
+declare class BalanceQueries {
+  static all: readonly ["balances"];
+  static lists: readonly ["balances", "tokenBalances"];
+  static collectionBalanceDetails: readonly ["balances", "collectionBalanceDetails"];
+}
+declare class CheckoutKeys {
+  static all: readonly ["checkouts"];
+  static options: readonly ["checkouts", "options"];
+  static cartItems: readonly ["checkouts", "cartItems"];
+}
+declare class CurrencyKeys {
+  static all: readonly ["currencies"];
+  static lists: readonly ["currencies", "list"];
+  static details: readonly ["currencies", "details"];
+  static conversion: readonly ["currencies", "conversion"];
+}
+declare class ConfigKeys {
+  static all: readonly ["configs"];
+  static marketplace: readonly ["configs", "marketplace"];
+}
+declare class MetadataKeys {
+  static all: readonly ["metadata"];
+  static tokenMetadata: readonly ["metadata", "tokenMetadata"];
+}
+declare const collectableKeys: typeof CollectableKeys;
+declare const collectionKeys: typeof CollectionKeys;
+declare const balanceQueries: typeof BalanceQueries;
+declare const checkoutKeys: typeof CheckoutKeys;
+declare const currencyKeys: typeof CurrencyKeys;
+declare const configKeys: typeof ConfigKeys;
+declare const metadataKeys: typeof MetadataKeys;
+//#endregion
+//#region src/react/_internal/api/services.d.ts
+type ChainNameOrId = string | number;
+declare const sequenceApiUrl: (env?: Env) => string;
+declare const getBuilderClient: (config: SdkConfig) => BuilderAPI;
+declare const getMetadataClient: (config: SdkConfig) => SequenceMetadata;
+declare const getIndexerClient: (chain: ChainNameOrId, config: SdkConfig) => SequenceIndexer;
+declare const getMarketplaceClient: (config: SdkConfig) => SequenceMarketplace;
+declare const getSequenceApiClient: (config: SdkConfig) => SequenceAPIClient;
+//#endregion
+export { LaosAPI, PaginationOptions, SequenceMarketplace, SortOption, TokenBalancesParams, TokenSuppliesParams, balanceQueries, checkoutKeys, collectableKeys, collectionKeys, configKeys, currencyKeys, getBuilderClient, getIndexerClient, getMarketplaceClient, getMetadataClient, getQueryClient, getSequenceApiClient, metadataKeys, sequenceApiUrl };
+//# sourceMappingURL=index-DsfCs3-x.d.ts.map

package/dist/index-DvpBZgor.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/index-dUb6wb4Y.d.ts

@@ -0,0 +1,22 @@
+import { LookupMarketplaceReturn, MarketplaceConfig, SdkConfig } from "./new-marketplace-types-Bfis0U4J.js";
+import * as _tanstack_react_query110 from "@tanstack/react-query";
+
+//#region src/react/queries/marketplaceConfig.d.ts
+declare const fetchMarketplaceConfig: ({
+  config,
+  prefetchedMarketplaceSettings
+}: {
+  config: SdkConfig;
+  prefetchedMarketplaceSettings?: LookupMarketplaceReturn;
+}) => Promise<MarketplaceConfig>;
+declare const marketplaceConfigOptions: (config: SdkConfig) => _tanstack_react_query110.OmitKeyof<_tanstack_react_query110.UseQueryOptions<MarketplaceConfig, Error, MarketplaceConfig, ("configs" | "marketplace")[]>, "queryFn"> & {
+  queryFn?: _tanstack_react_query110.QueryFunction<MarketplaceConfig, ("configs" | "marketplace")[], never> | undefined;
+} & {
+  queryKey: ("configs" | "marketplace")[] & {
+    [dataTagSymbol]: MarketplaceConfig;
+    [dataTagErrorSymbol]: Error;
+  };
+};
+//#endregion
+export { fetchMarketplaceConfig, marketplaceConfigOptions };
+//# sourceMappingURL=index-dUb6wb4Y.d.ts.map