@0xsequence/marketplace-sdk 0.0.1

package/dist/chunk-HGBEC3WX.js

@@ -0,0 +1,1285 @@
+"use client"
+
+// src/react/_internal/api/get-query-client.ts
+import {
+  QueryClient,
+  defaultShouldDehydrateQuery
+} from "@tanstack/react-query";
+import { hashFn } from "wagmi/query";
+function makeQueryClient() {
+  return new QueryClient({
+    defaultOptions: {
+      queries: {
+        staleTime: 60 * 1e3,
+        queryKeyHashFn: hashFn
+      },
+      dehydrate: {
+        shouldDehydrateQuery: (query) => defaultShouldDehydrateQuery(query) || query.state.status === "pending"
+      }
+    }
+  });
+}
+var browserQueryClient = void 0;
+function getQueryClient() {
+  if (typeof globalThis.document === "undefined") {
+    return makeQueryClient();
+  } else {
+    if (!browserQueryClient) browserQueryClient = makeQueryClient();
+    return browserQueryClient;
+  }
+}
+
+// src/react/_internal/api/marketplace.gen.ts
+var WebrpcHeader = "Webrpc";
+var WebrpcHeaderValue = "webrpc@v0.21.0;gen-typescript@v0.15.0;marketplace-api@v0.0.0-272a2d3c9208fb21b84c88a2a8cbd9ab8e29964d";
+var WebRPCVersion = "v1";
+var WebRPCSchemaVersion = "";
+var WebRPCSchemaHash = "272a2d3c9208fb21b84c88a2a8cbd9ab8e29964d";
+function VersionFromHeader(headers) {
+  const headerValue = headers.get(WebrpcHeader);
+  if (!headerValue) {
+    return {
+      webrpcGenVersion: "",
+      codeGenName: "",
+      codeGenVersion: "",
+      schemaName: "",
+      schemaVersion: ""
+    };
+  }
+  return parseWebrpcGenVersions(headerValue);
+}
+function parseWebrpcGenVersions(header) {
+  const versions = header.split(";");
+  if (versions.length < 3) {
+    return {
+      webrpcGenVersion: "",
+      codeGenName: "",
+      codeGenVersion: "",
+      schemaName: "",
+      schemaVersion: ""
+    };
+  }
+  const [_, webrpcGenVersion] = versions[0].split("@");
+  const [codeGenName, codeGenVersion] = versions[1].split("@");
+  const [schemaName, schemaVersion] = versions[2].split("@");
+  return {
+    webrpcGenVersion,
+    codeGenName,
+    codeGenVersion,
+    schemaName,
+    schemaVersion
+  };
+}
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["DESC"] = "DESC";
+  SortOrder2["ASC"] = "ASC";
+  return SortOrder2;
+})(SortOrder || {});
+var PropertyType = /* @__PURE__ */ ((PropertyType2) => {
+  PropertyType2["INT"] = "INT";
+  PropertyType2["STRING"] = "STRING";
+  PropertyType2["ARRAY"] = "ARRAY";
+  PropertyType2["GENERIC"] = "GENERIC";
+  return PropertyType2;
+})(PropertyType || {});
+var MarketplaceKind = /* @__PURE__ */ ((MarketplaceKind2) => {
+  MarketplaceKind2["unknown"] = "unknown";
+  MarketplaceKind2["sequence_marketplace_v1"] = "sequence_marketplace_v1";
+  MarketplaceKind2["sequence_marketplace_v2"] = "sequence_marketplace_v2";
+  MarketplaceKind2["opensea"] = "opensea";
+  MarketplaceKind2["magic_eden"] = "magic_eden";
+  MarketplaceKind2["mintify"] = "mintify";
+  MarketplaceKind2["looks_rare"] = "looks_rare";
+  MarketplaceKind2["x2y2"] = "x2y2";
+  MarketplaceKind2["sudo_swap"] = "sudo_swap";
+  MarketplaceKind2["coinbase"] = "coinbase";
+  MarketplaceKind2["rarible"] = "rarible";
+  MarketplaceKind2["nftx"] = "nftx";
+  MarketplaceKind2["foundation"] = "foundation";
+  MarketplaceKind2["manifold"] = "manifold";
+  MarketplaceKind2["zora"] = "zora";
+  MarketplaceKind2["blur"] = "blur";
+  MarketplaceKind2["super_rare"] = "super_rare";
+  MarketplaceKind2["okx"] = "okx";
+  MarketplaceKind2["element"] = "element";
+  MarketplaceKind2["aqua_xyz"] = "aqua_xyz";
+  MarketplaceKind2["auranft_co"] = "auranft_co";
+  return MarketplaceKind2;
+})(MarketplaceKind || {});
+var OrderbookKind = /* @__PURE__ */ ((OrderbookKind2) => {
+  OrderbookKind2["unknown"] = "unknown";
+  OrderbookKind2["sequence_marketplace_v1"] = "sequence_marketplace_v1";
+  OrderbookKind2["sequence_marketplace_v2"] = "sequence_marketplace_v2";
+  OrderbookKind2["blur"] = "blur";
+  OrderbookKind2["opensea"] = "opensea";
+  OrderbookKind2["looks_rare"] = "looks_rare";
+  OrderbookKind2["reservoir"] = "reservoir";
+  OrderbookKind2["x2y2"] = "x2y2";
+  return OrderbookKind2;
+})(OrderbookKind || {});
+var SourceKind = /* @__PURE__ */ ((SourceKind2) => {
+  SourceKind2["unknown"] = "unknown";
+  SourceKind2["external"] = "external";
+  SourceKind2["sequence_marketplace_v1"] = "sequence_marketplace_v1";
+  SourceKind2["sequence_marketplace_v2"] = "sequence_marketplace_v2";
+  return SourceKind2;
+})(SourceKind || {});
+var OrderSide = /* @__PURE__ */ ((OrderSide2) => {
+  OrderSide2["unknown"] = "unknown";
+  OrderSide2["listing"] = "listing";
+  OrderSide2["offer"] = "offer";
+  return OrderSide2;
+})(OrderSide || {});
+var OrderStatus = /* @__PURE__ */ ((OrderStatus2) => {
+  OrderStatus2["unknown"] = "unknown";
+  OrderStatus2["active"] = "active";
+  OrderStatus2["inactive"] = "inactive";
+  OrderStatus2["expired"] = "expired";
+  OrderStatus2["cancelled"] = "cancelled";
+  OrderStatus2["filled"] = "filled";
+  return OrderStatus2;
+})(OrderStatus || {});
+var ContractType = /* @__PURE__ */ ((ContractType2) => {
+  ContractType2["UNKNOWN"] = "UNKNOWN";
+  ContractType2["ERC20"] = "ERC20";
+  ContractType2["ERC721"] = "ERC721";
+  ContractType2["ERC1155"] = "ERC1155";
+  return ContractType2;
+})(ContractType || {});
+var CollectionStatus = /* @__PURE__ */ ((CollectionStatus2) => {
+  CollectionStatus2["unknown"] = "unknown";
+  CollectionStatus2["created"] = "created";
+  CollectionStatus2["syncing_metadata"] = "syncing_metadata";
+  CollectionStatus2["synced_metadata"] = "synced_metadata";
+  CollectionStatus2["syncing_tokens"] = "syncing_tokens";
+  CollectionStatus2["synced_tokens"] = "synced_tokens";
+  CollectionStatus2["syncing_orders"] = "syncing_orders";
+  CollectionStatus2["active"] = "active";
+  CollectionStatus2["failed"] = "failed";
+  CollectionStatus2["inactive"] = "inactive";
+  return CollectionStatus2;
+})(CollectionStatus || {});
+var ProjectStatus = /* @__PURE__ */ ((ProjectStatus2) => {
+  ProjectStatus2["unknown"] = "unknown";
+  ProjectStatus2["active"] = "active";
+  ProjectStatus2["inactive"] = "inactive";
+  return ProjectStatus2;
+})(ProjectStatus || {});
+var CollectibleStatus = /* @__PURE__ */ ((CollectibleStatus2) => {
+  CollectibleStatus2["unknown"] = "unknown";
+  CollectibleStatus2["active"] = "active";
+  CollectibleStatus2["inactive"] = "inactive";
+  return CollectibleStatus2;
+})(CollectibleStatus || {});
+var WalletKind = /* @__PURE__ */ ((WalletKind2) => {
+  WalletKind2["unknown"] = "unknown";
+  WalletKind2["sequence"] = "sequence";
+  return WalletKind2;
+})(WalletKind || {});
+var StepType = /* @__PURE__ */ ((StepType2) => {
+  StepType2["unknown"] = "unknown";
+  StepType2["tokenApproval"] = "tokenApproval";
+  StepType2["buy"] = "buy";
+  StepType2["sell"] = "sell";
+  StepType2["createListing"] = "createListing";
+  StepType2["createOffer"] = "createOffer";
+  StepType2["signEIP712"] = "signEIP712";
+  StepType2["signEIP191"] = "signEIP191";
+  return StepType2;
+})(StepType || {});
+var TransactionCrypto = /* @__PURE__ */ ((TransactionCrypto2) => {
+  TransactionCrypto2["none"] = "none";
+  TransactionCrypto2["partially"] = "partially";
+  TransactionCrypto2["all"] = "all";
+  return TransactionCrypto2;
+})(TransactionCrypto || {});
+var TransactionNFTCheckoutProvider = /* @__PURE__ */ ((TransactionNFTCheckoutProvider2) => {
+  TransactionNFTCheckoutProvider2["unknown"] = "unknown";
+  TransactionNFTCheckoutProvider2["sardine"] = "sardine";
+  TransactionNFTCheckoutProvider2["transak"] = "transak";
+  return TransactionNFTCheckoutProvider2;
+})(TransactionNFTCheckoutProvider || {});
+var TransactionOnRampProvider = /* @__PURE__ */ ((TransactionOnRampProvider2) => {
+  TransactionOnRampProvider2["unknown"] = "unknown";
+  TransactionOnRampProvider2["sardine"] = "sardine";
+  TransactionOnRampProvider2["transak"] = "transak";
+  return TransactionOnRampProvider2;
+})(TransactionOnRampProvider || {});
+var TransactionSwapProvider = /* @__PURE__ */ ((TransactionSwapProvider2) => {
+  TransactionSwapProvider2["unknown"] = "unknown";
+  TransactionSwapProvider2["zerox"] = "zerox";
+  return TransactionSwapProvider2;
+})(TransactionSwapProvider || {});
+var ExecuteType = /* @__PURE__ */ ((ExecuteType2) => {
+  ExecuteType2["unknown"] = "unknown";
+  ExecuteType2["order"] = "order";
+  return ExecuteType2;
+})(ExecuteType || {});
+var Admin = class {
+  hostname;
+  fetch;
+  path = "/rpc/Admin/";
+  constructor(hostname, fetch2) {
+    this.hostname = hostname.replace(/\/*$/, "");
+    this.fetch = (input, init) => fetch2(input, init);
+  }
+  url(name) {
+    return this.hostname + this.path + name;
+  }
+  createCollection = (args, headers, signal) => {
+    return this.fetch(
+      this.url("CreateCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collection: _data.collection
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollection = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collection: _data.collection
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollections = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollections"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collections: _data.collections,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  deleteCollection = (args, headers, signal) => {
+    return this.fetch(
+      this.url("DeleteCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collection: _data.collection
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  syncCollection = (args, headers, signal) => {
+    return this.fetch(
+      this.url("SyncCollection"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collection: _data.collection
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  createCurrency = (args, headers, signal) => {
+    return this.fetch(
+      this.url("CreateCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currency: _data.currency
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  createCurrencies = (args, headers, signal) => {
+    return this.fetch(
+      this.url("CreateCurrencies"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currency: _data.currency
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  updateCurrency = (args, headers, signal) => {
+    return this.fetch(
+      this.url("UpdateCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currency: _data.currency
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCurrencies = (headers, signal) => {
+    return this.fetch(
+      this.url("ListCurrencies"),
+      createHTTPRequest({}, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currencies: _data.currencies
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  deleteCurrency = (args, headers, signal) => {
+    return this.fetch(
+      this.url("DeleteCurrency"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currency: _data.currency
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+};
+var Marketplace = class {
+  hostname;
+  fetch;
+  path = "/rpc/Marketplace/";
+  constructor(hostname, fetch2) {
+    this.hostname = hostname.replace(/\/*$/, "");
+    this.fetch = (input, init) => fetch2(input, init);
+  }
+  url(name) {
+    return this.hostname + this.path + name;
+  }
+  listCurrencies = (headers, signal) => {
+    return this.fetch(
+      this.url("ListCurrencies"),
+      createHTTPRequest({}, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          currencies: _data.currencies
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          metadata: _data.metadata
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getLowestPriceOfferForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetLowestPriceOfferForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getHighestPriceOfferForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetHighestPriceOfferForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getLowestPriceListingForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetLowestPriceListingForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getHighestPriceListingForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetHighestPriceListingForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listListingsForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListListingsForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          listings: _data.listings,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listOffersForCollectible = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListOffersForCollectible"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          offers: _data.offers,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollectibleLowestOffer = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollectibleLowestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollectibleHighestOffer = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollectibleHighestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollectibleLowestListing = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollectibleLowestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCollectibleHighestListing = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCollectibleHighestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          order: _data.order
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollectibleListings = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollectibleListings"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          listings: _data.listings,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollectibleOffers = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollectibleOffers"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          offers: _data.offers,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  generateBuyTransaction = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GenerateBuyTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          steps: _data.steps
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  generateSellTransaction = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GenerateSellTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          steps: _data.steps
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  generateListingTransaction = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GenerateListingTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          steps: _data.steps
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  generateOfferTransaction = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GenerateOfferTransaction"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          steps: _data.steps
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  execute = (args, headers, signal) => {
+    return this.fetch(
+      this.url("Execute"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          orderId: _data.orderId
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollectibles = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collectibles: _data.collectibles,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCountOfAllCollectibles = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCountOfAllCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          count: _data.count
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getCountOfFilteredCollectibles = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetCountOfFilteredCollectibles"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          count: _data.count
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getFloorOrder = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetFloorOrder"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collectible: _data.collectible
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollectiblesWithLowestListing = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollectiblesWithLowestListing"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collectibles: _data.collectibles,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  listCollectiblesWithHighestOffer = (args, headers, signal) => {
+    return this.fetch(
+      this.url("ListCollectiblesWithHighestOffer"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          collectibles: _data.collectibles,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  syncOrder = (args, headers, signal) => {
+    return this.fetch(
+      this.url("SyncOrder"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {};
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  syncOrders = (args, headers, signal) => {
+    return this.fetch(
+      this.url("SyncOrders"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {};
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  getOrders = (args, headers, signal) => {
+    return this.fetch(
+      this.url("GetOrders"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          orders: _data.orders,
+          page: _data.page
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  checkoutOptionsMarketplace = (args, headers, signal) => {
+    return this.fetch(
+      this.url("CheckoutOptionsMarketplace"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          options: _data.options
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+  checkoutOptionsSalesContract = (args, headers, signal) => {
+    return this.fetch(
+      this.url("CheckoutOptionsSalesContract"),
+      createHTTPRequest(args, headers, signal)
+    ).then((res) => {
+      return buildResponse(res).then((_data) => {
+        return {
+          options: _data.options
+        };
+      });
+    }, (error) => {
+      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ""}` });
+    });
+  };
+};
+var createHTTPRequest = (body = {}, headers = {}, signal = null) => {
+  const reqHeaders = { ...headers, "Content-Type": "application/json" };
+  reqHeaders[WebrpcHeader] = WebrpcHeaderValue;
+  return {
+    method: "POST",
+    headers: reqHeaders,
+    body: JSON.stringify(body || {}),
+    signal
+  };
+};
+var buildResponse = (res) => {
+  return res.text().then((text) => {
+    let data;
+    try {
+      data = JSON.parse(text);
+    } catch (error) {
+      let message = "";
+      if (error instanceof Error) {
+        message = error.message;
+      }
+      throw WebrpcBadResponseError.new(
+        {
+          status: res.status,
+          cause: `JSON.parse(): ${message}: response text: ${text}`
+        }
+      );
+    }
+    if (!res.ok) {
+      const code = typeof data.code === "number" ? data.code : 0;
+      throw (webrpcErrorByCode[code] || WebrpcError).new(data);
+    }
+    return data;
+  });
+};
+var WebrpcError = class _WebrpcError extends Error {
+  name;
+  code;
+  message;
+  status;
+  cause;
+  /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
+  msg;
+  constructor(name, code, message, status, cause) {
+    super(message);
+    this.name = name || "WebrpcError";
+    this.code = typeof code === "number" ? code : 0;
+    this.message = message || `endpoint error ${this.code}`;
+    this.msg = this.message;
+    this.status = typeof status === "number" ? status : 0;
+    this.cause = cause;
+    Object.setPrototypeOf(this, _WebrpcError.prototype);
+  }
+  static new(payload) {
+    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause);
+  }
+};
+var WebrpcEndpointError = class _WebrpcEndpointError extends WebrpcError {
+  constructor(name = "WebrpcEndpoint", code = 0, message = "endpoint error", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcEndpointError.prototype);
+  }
+};
+var WebrpcRequestFailedError = class _WebrpcRequestFailedError extends WebrpcError {
+  constructor(name = "WebrpcRequestFailed", code = -1, message = "request failed", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcRequestFailedError.prototype);
+  }
+};
+var WebrpcBadRouteError = class _WebrpcBadRouteError extends WebrpcError {
+  constructor(name = "WebrpcBadRoute", code = -2, message = "bad route", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcBadRouteError.prototype);
+  }
+};
+var WebrpcBadMethodError = class _WebrpcBadMethodError extends WebrpcError {
+  constructor(name = "WebrpcBadMethod", code = -3, message = "bad method", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcBadMethodError.prototype);
+  }
+};
+var WebrpcBadRequestError = class _WebrpcBadRequestError extends WebrpcError {
+  constructor(name = "WebrpcBadRequest", code = -4, message = "bad request", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcBadRequestError.prototype);
+  }
+};
+var WebrpcBadResponseError = class _WebrpcBadResponseError extends WebrpcError {
+  constructor(name = "WebrpcBadResponse", code = -5, message = "bad response", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcBadResponseError.prototype);
+  }
+};
+var WebrpcServerPanicError = class _WebrpcServerPanicError extends WebrpcError {
+  constructor(name = "WebrpcServerPanic", code = -6, message = "server panic", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcServerPanicError.prototype);
+  }
+};
+var WebrpcInternalErrorError = class _WebrpcInternalErrorError extends WebrpcError {
+  constructor(name = "WebrpcInternalError", code = -7, message = "internal error", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcInternalErrorError.prototype);
+  }
+};
+var WebrpcClientDisconnectedError = class _WebrpcClientDisconnectedError extends WebrpcError {
+  constructor(name = "WebrpcClientDisconnected", code = -8, message = "client disconnected", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcClientDisconnectedError.prototype);
+  }
+};
+var WebrpcStreamLostError = class _WebrpcStreamLostError extends WebrpcError {
+  constructor(name = "WebrpcStreamLost", code = -9, message = "stream lost", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcStreamLostError.prototype);
+  }
+};
+var WebrpcStreamFinishedError = class _WebrpcStreamFinishedError extends WebrpcError {
+  constructor(name = "WebrpcStreamFinished", code = -10, message = "stream finished", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _WebrpcStreamFinishedError.prototype);
+  }
+};
+var UnauthorizedError = class _UnauthorizedError extends WebrpcError {
+  constructor(name = "Unauthorized", code = 1e3, message = "Unauthorized access", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _UnauthorizedError.prototype);
+  }
+};
+var PermissionDeniedError = class _PermissionDeniedError extends WebrpcError {
+  constructor(name = "PermissionDenied", code = 1001, message = "Permission denied", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _PermissionDeniedError.prototype);
+  }
+};
+var SessionExpiredError = class _SessionExpiredError extends WebrpcError {
+  constructor(name = "SessionExpired", code = 1002, message = "Session expired", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _SessionExpiredError.prototype);
+  }
+};
+var MethodNotFoundError = class _MethodNotFoundError extends WebrpcError {
+  constructor(name = "MethodNotFound", code = 1003, message = "Method not found", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _MethodNotFoundError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends WebrpcError {
+  constructor(name = "Timeout", code = 2e3, message = "Request timed out", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var InvalidArgumentError = class _InvalidArgumentError extends WebrpcError {
+  constructor(name = "InvalidArgument", code = 2001, message = "Invalid argument", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _InvalidArgumentError.prototype);
+  }
+};
+var NotFoundError = class _NotFoundError extends WebrpcError {
+  constructor(name = "NotFound", code = 3e3, message = "Resource not found", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _NotFoundError.prototype);
+  }
+};
+var UserNotFoundError = class _UserNotFoundError extends WebrpcError {
+  constructor(name = "UserNotFound", code = 3001, message = "User not found", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _UserNotFoundError.prototype);
+  }
+};
+var ProjectNotFoundError = class _ProjectNotFoundError extends WebrpcError {
+  constructor(name = "ProjectNotFound", code = 3002, message = "Project not found", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _ProjectNotFoundError.prototype);
+  }
+};
+var InvalidTierError = class _InvalidTierError extends WebrpcError {
+  constructor(name = "InvalidTier", code = 3003, message = "Invalid subscription tier", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _InvalidTierError.prototype);
+  }
+};
+var ProjectLimitReachedError = class _ProjectLimitReachedError extends WebrpcError {
+  constructor(name = "ProjectLimitReached", code = 3005, message = "Project limit reached", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _ProjectLimitReachedError.prototype);
+  }
+};
+var NotImplementedError = class _NotImplementedError extends WebrpcError {
+  constructor(name = "NotImplemented", code = 9999, message = "Not Implemented", status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, _NotImplementedError.prototype);
+  }
+};
+var errors = /* @__PURE__ */ ((errors2) => {
+  errors2["WebrpcEndpoint"] = "WebrpcEndpoint";
+  errors2["WebrpcRequestFailed"] = "WebrpcRequestFailed";
+  errors2["WebrpcBadRoute"] = "WebrpcBadRoute";
+  errors2["WebrpcBadMethod"] = "WebrpcBadMethod";
+  errors2["WebrpcBadRequest"] = "WebrpcBadRequest";
+  errors2["WebrpcBadResponse"] = "WebrpcBadResponse";
+  errors2["WebrpcServerPanic"] = "WebrpcServerPanic";
+  errors2["WebrpcInternalError"] = "WebrpcInternalError";
+  errors2["WebrpcClientDisconnected"] = "WebrpcClientDisconnected";
+  errors2["WebrpcStreamLost"] = "WebrpcStreamLost";
+  errors2["WebrpcStreamFinished"] = "WebrpcStreamFinished";
+  errors2["Unauthorized"] = "Unauthorized";
+  errors2["PermissionDenied"] = "PermissionDenied";
+  errors2["SessionExpired"] = "SessionExpired";
+  errors2["MethodNotFound"] = "MethodNotFound";
+  errors2["Timeout"] = "Timeout";
+  errors2["InvalidArgument"] = "InvalidArgument";
+  errors2["NotFound"] = "NotFound";
+  errors2["UserNotFound"] = "UserNotFound";
+  errors2["ProjectNotFound"] = "ProjectNotFound";
+  errors2["InvalidTier"] = "InvalidTier";
+  errors2["ProjectLimitReached"] = "ProjectLimitReached";
+  errors2["NotImplemented"] = "NotImplemented";
+  return errors2;
+})(errors || {});
+var webrpcErrorByCode = {
+  [0]: WebrpcEndpointError,
+  [-1]: WebrpcRequestFailedError,
+  [-2]: WebrpcBadRouteError,
+  [-3]: WebrpcBadMethodError,
+  [-4]: WebrpcBadRequestError,
+  [-5]: WebrpcBadResponseError,
+  [-6]: WebrpcServerPanicError,
+  [-7]: WebrpcInternalErrorError,
+  [-8]: WebrpcClientDisconnectedError,
+  [-9]: WebrpcStreamLostError,
+  [-10]: WebrpcStreamFinishedError,
+  [1e3]: UnauthorizedError,
+  [1001]: PermissionDeniedError,
+  [1002]: SessionExpiredError,
+  [1003]: MethodNotFoundError,
+  [2e3]: TimeoutError,
+  [2001]: InvalidArgumentError,
+  [3e3]: NotFoundError,
+  [3001]: UserNotFoundError,
+  [3002]: ProjectNotFoundError,
+  [3003]: InvalidTierError,
+  [3005]: ProjectLimitReachedError,
+  [9999]: NotImplementedError
+};
+
+// src/react/_internal/api/marketplace-api.ts
+var SequenceMarketplace = class extends Marketplace {
+  constructor(hostname, projectAccessKey, jwtAuth) {
+    super(hostname.endsWith("/") ? hostname.slice(0, -1) : hostname, fetch);
+    this.projectAccessKey = projectAccessKey;
+    this.jwtAuth = jwtAuth;
+    this.fetch = this._fetch;
+  }
+  _fetch = (input, init) => {
+    const headers = {};
+    const jwtAuth = this.jwtAuth;
+    const projectAccessKey = this.projectAccessKey;
+    if (jwtAuth && jwtAuth.length > 0) {
+      headers.Authorization = `BEARER ${jwtAuth}`;
+    }
+    if (projectAccessKey && projectAccessKey.length > 0) {
+      headers["X-Access-Key"] = projectAccessKey;
+    }
+    init.headers = { ...init.headers, ...headers };
+    return fetch(input, init);
+  };
+};
+
+// src/react/_internal/api/query-keys.ts
+var CollectableKeys = class _CollectableKeys {
+  static all = ["collectable"];
+  static details = [..._CollectableKeys.all, "details"];
+  static lists = [..._CollectableKeys.all, "list"];
+  static floorOrders = [..._CollectableKeys.all, "floorOrders"];
+  static userBalances = [
+    ..._CollectableKeys.all,
+    ..._CollectableKeys.details,
+    "userBalances"
+  ];
+  static royaltyPercentage = [
+    ..._CollectableKeys.all,
+    "royaltyPercentage"
+  ];
+  static highestOffers = [
+    ..._CollectableKeys.all,
+    ..._CollectableKeys.details,
+    "highestOffers"
+  ];
+  static lowestListings = [
+    ..._CollectableKeys.all,
+    ..._CollectableKeys.details,
+    "lowestListings"
+  ];
+  static offers = [..._CollectableKeys.all, "offers"];
+  static filter = [..._CollectableKeys.all, "filter"];
+  static counts = [..._CollectableKeys.all, "counts"];
+};
+var CollectionKeys = class _CollectionKeys {
+  static all = ["collections"];
+  static list = [..._CollectionKeys.all, "list"];
+  static detail = [..._CollectionKeys.all, "detail"];
+};
+var BalanceQueries = class _BalanceQueries {
+  static all = ["balances"];
+  static lists = [..._BalanceQueries.all, "tokenBalances"];
+};
+var CheckoutKeys = class _CheckoutKeys {
+  static all = ["checkouts"];
+  static options = [..._CheckoutKeys.all, "options"];
+  static cartItems = [..._CheckoutKeys.all, "cartItems"];
+};
+var CurrencyKeys = class _CurrencyKeys {
+  static all = ["currencies"];
+  static lists = [..._CurrencyKeys.all, "list"];
+};
+var ConfigKeys = class _ConfigKeys {
+  static all = ["configs"];
+  static marketplace = [..._ConfigKeys.all, "marketplace"];
+};
+var collectableKeys = CollectableKeys;
+var collectionKeys = CollectionKeys;
+var balanceQueries = BalanceQueries;
+var checkoutKeys = CheckoutKeys;
+var currencyKeys = CurrencyKeys;
+var configKeys = ConfigKeys;
+
+// src/react/_internal/api/services.ts
+import { SequenceIndexer } from "@0xsequence/indexer";
+import { SequenceMetadata } from "@0xsequence/metadata";
+import { networks, stringTemplate } from "@0xsequence/network";
+var SERVICES = {
+  sequenceApi: "https://api.sequence.app",
+  metadata: "https://${prefix}metadata.sequence.app",
+  indexer: "https://${prefix}${network}-indexer.sequence.app",
+  marketplaceApi: "https://${prefix}marketplace-api.sequence.app/${network}",
+  imageProxy: "https://imgproxy.sequence.xyz/",
+  builderMarketplaceApi: "https://${prefix}api.sequence.build/marketplace/${projectId}"
+};
+var getNetwork = (nameOrId) => {
+  for (const network of Object.values(networks)) {
+    if (network.name === String(nameOrId).toLowerCase() || network.chainId === Number(nameOrId)) {
+      return network;
+    }
+  }
+  throw new Error(`Unsopported chain; ${nameOrId}`);
+};
+var imageProxy = stringTemplate(SERVICES.imageProxy, {});
+var metadataURL = (env = "production") => {
+  const prefix = getPrefix(env);
+  return stringTemplate(SERVICES.metadata, { prefix });
+};
+var indexerURL = (chain, env = "production") => {
+  const prefix = getPrefix(env);
+  const network = getNetwork(chain).name;
+  return stringTemplate(SERVICES.indexer, { network, prefix });
+};
+var marketplaceApiURL = (chain, env = "production") => {
+  const prefix = getPrefix(env);
+  const network = getNetwork(chain).name;
+  return stringTemplate(SERVICES.marketplaceApi, { network, prefix });
+};
+var builderMarketplaceApi = (projectId, env = "production") => {
+  const prefix = getPrefix(env);
+  return stringTemplate(SERVICES.builderMarketplaceApi, {
+    projectId,
+    prefix
+  });
+};
+var getMetadataClient = (config) => {
+  const env = config._internal?.metadataEnv || "production";
+  const projectAccessKey = getAccessKey({ env, config });
+  return new SequenceMetadata(metadataURL(env), projectAccessKey);
+};
+var getIndexerClient = (chain, config) => {
+  const env = config._internal?.indexerEnv || "production";
+  const projectAccessKey = getAccessKey({ env, config });
+  return new SequenceIndexer(indexerURL(chain, env), projectAccessKey);
+};
+var getMarketplaceClient = (chain, config) => {
+  const env = config._internal?.marketplaceEnv || "production";
+  const projectAccessKey = getAccessKey({ env, config });
+  return new SequenceMarketplace(
+    marketplaceApiURL(chain, env),
+    projectAccessKey
+  );
+};
+var getAccessKey = ({ env, config }) => {
+  switch (env) {
+    case "development":
+      if (!config._internal?.devAccessKey)
+        throw new Error("devAccessKey is required for development env");
+      return config._internal?.devAccessKey;
+    case "production":
+      return config.projectAccessKey;
+    case "next":
+      if (!config._internal?.nextAccessKey)
+        throw new Error("nextAccessKey is required for next env");
+      return config._internal?.nextAccessKey;
+  }
+};
+var getPrefix = (env) => {
+  switch (env) {
+    case "development":
+      return "dev-";
+    case "production":
+      return "";
+    case "next":
+      return "next-";
+  }
+};
+
+export {
+  getQueryClient,
+  WebrpcHeader,
+  WebrpcHeaderValue,
+  WebRPCVersion,
+  WebRPCSchemaVersion,
+  WebRPCSchemaHash,
+  VersionFromHeader,
+  SortOrder,
+  PropertyType,
+  MarketplaceKind,
+  OrderbookKind,
+  SourceKind,
+  OrderSide,
+  OrderStatus,
+  ContractType,
+  CollectionStatus,
+  ProjectStatus,
+  CollectibleStatus,
+  WalletKind,
+  StepType,
+  TransactionCrypto,
+  TransactionNFTCheckoutProvider,
+  TransactionOnRampProvider,
+  TransactionSwapProvider,
+  ExecuteType,
+  Admin,
+  Marketplace,
+  WebrpcError,
+  WebrpcEndpointError,
+  WebrpcRequestFailedError,
+  WebrpcBadRouteError,
+  WebrpcBadMethodError,
+  WebrpcBadRequestError,
+  WebrpcBadResponseError,
+  WebrpcServerPanicError,
+  WebrpcInternalErrorError,
+  WebrpcClientDisconnectedError,
+  WebrpcStreamLostError,
+  WebrpcStreamFinishedError,
+  UnauthorizedError,
+  PermissionDeniedError,
+  SessionExpiredError,
+  MethodNotFoundError,
+  TimeoutError,
+  InvalidArgumentError,
+  NotFoundError,
+  UserNotFoundError,
+  ProjectNotFoundError,
+  InvalidTierError,
+  ProjectLimitReachedError,
+  NotImplementedError,
+  errors,
+  SequenceMarketplace,
+  collectableKeys,
+  collectionKeys,
+  balanceQueries,
+  checkoutKeys,
+  currencyKeys,
+  configKeys,
+  imageProxy,
+  builderMarketplaceApi,
+  getMetadataClient,
+  getIndexerClient,
+  getMarketplaceClient
+};
+//# sourceMappingURL=chunk-HGBEC3WX.js.map