@avalabs/glacier-sdk 2.8.0-alpha.11 → 2.8.0-alpha.110

package/dist/index.js

@@ -1,157 +1,1595 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var utilsSdk = require('@avalabs/utils-sdk');
-
-/* eslint-disable */
-/* tslint:disable */
-/*
- * ---------------------------------------------------------------
- * ## THIS FILE WAS GENERATED VIA SWAGGER-TYPESCRIPT-API        ##
- * ##                                                           ##
- * ## AUTHOR: acacode                                           ##
- * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
- * ---------------------------------------------------------------
- */
-exports.CurrencyCode = void 0;
-(function (CurrencyCode) {
-    CurrencyCode["Usd"] = "usd";
-    CurrencyCode["Eur"] = "eur";
-    CurrencyCode["Aud"] = "aud";
-    CurrencyCode["Cad"] = "cad";
-    CurrencyCode["Chf"] = "chf";
-    CurrencyCode["Clp"] = "clp";
-    CurrencyCode["Czk"] = "czk";
-    CurrencyCode["Dkk"] = "dkk";
-    CurrencyCode["Gbp"] = "gbp";
-    CurrencyCode["Hkd"] = "hkd";
-    CurrencyCode["Huf"] = "huf";
-})(exports.CurrencyCode || (exports.CurrencyCode = {}));
-exports.Erc721MetadataStatus = void 0;
-(function (Erc721MetadataStatus) {
-    Erc721MetadataStatus["UNKNOWN"] = "UNKNOWN";
-    Erc721MetadataStatus["MISSING_TOKEN"] = "MISSING_TOKEN";
-    Erc721MetadataStatus["INVALID_TOKEN_URI"] = "INVALID_TOKEN_URI";
-    Erc721MetadataStatus["INVALID_TOKEN_URI_SCHEME"] = "INVALID_TOKEN_URI_SCHEME";
-    Erc721MetadataStatus["UNREACHABLE_TOKEN_URI"] = "UNREACHABLE_TOKEN_URI";
-    Erc721MetadataStatus["THROTTLED_TOKEN_URI"] = "THROTTLED_TOKEN_URI";
-    Erc721MetadataStatus["METADATA_CONTENT_TOO_LARGE"] = "METADATA_CONTENT_TOO_LARGE";
-    Erc721MetadataStatus["INVALID_METADATA"] = "INVALID_METADATA";
-    Erc721MetadataStatus["INVALID_METADATA_JSON"] = "INVALID_METADATA_JSON";
-    Erc721MetadataStatus["INDEXED"] = "INDEXED";
-    Erc721MetadataStatus["UNINDEXED"] = "UNINDEXED";
-})(exports.Erc721MetadataStatus || (exports.Erc721MetadataStatus = {}));
-exports.InternalTransactionOpCall = void 0;
-(function (InternalTransactionOpCall) {
-    InternalTransactionOpCall["UNKNOWN"] = "UNKNOWN";
-    InternalTransactionOpCall["CALL"] = "CALL";
-    InternalTransactionOpCall["CREATE"] = "CREATE";
-    InternalTransactionOpCall["CREATE2"] = "CREATE2";
-    InternalTransactionOpCall["CALLCODE"] = "CALLCODE";
-    InternalTransactionOpCall["DELEGATECALL"] = "DELEGATECALL";
-    InternalTransactionOpCall["STATICCALL"] = "STATICCALL";
-})(exports.InternalTransactionOpCall || (exports.InternalTransactionOpCall = {}));
-exports.VmName = void 0;
-(function (VmName) {
-    VmName["EVM"] = "EVM";
-    VmName["BITCOIN"] = "BITCOIN";
-    VmName["ETHEREUM"] = "ETHEREUM";
-})(exports.VmName || (exports.VmName = {}));
-
-class GlacierClient {
-    constructor(baseUrl, version = 'v1', httpOptions) {
-        this.baseUrl = baseUrl;
-        this.version = version;
-        this.httpOptions = httpOptions;
-        this.httpClient = new utilsSdk.HttpClient(`${this.baseUrl}/${this.version}`, this.httpOptions);
-    }
-    /**
-     *
-     * @name HealthCheck
-     * @summary Get the health of the service.
-     * @request GET:/${version}/health-check
-     * @response `200` `{ status?: string, info?: Record<string, { status?: string }>, error?: Record<string, { status?: string }>, details?: Record<string, { status?: string }> }` The Health Check is successful
-     * @response `503` `{ status?: string, info?: Record<string, { status?: string }>, error?: Record<string, { status?: string }>, details?: Record<string, { status?: string }> }` The Health Check is not successful
-     */
-    healthCheck(params = {}, customOptions = {}) {
-        return this.httpClient.get(`/health-check`, params, customOptions);
-    }
-    /**
-     * No description
-     *
-     * @name GetNativeBalance
-     * @summary Get native token balance of a wallet address for a given chain.
-     * @request GET:/v1/chains/{chainId}/addresses/{address}/balances:getNative
-     * @response `200` `NativeBalanceDto`
-     */
-    getNativeBalance(chainId, address, query, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}/addresses/${address}/balances:getNative`, Object.assign(Object.assign({}, query), params), customOptions);
-    }
-    /**
-     *
-     * @name ListErc20Balances
-     * @summary Get erc-20 token balances of a wallet address for a given chain.
-     * @request GET:/v1/chains/{chainId}/addresses/{address}/balances:listErc20
-     * @response `200` `Erc20BalancesDto`
-     */
-    listErc20Balances(chainId, address, query, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}/addresses/${address}/balances:listErc20`, Object.assign(Object.assign({}, query), params), customOptions);
-    }
-    /**
-     * No description
-     *
-     * @name ListErc721Balances
-     * @summary Get erc-721 token balances of a wallet address for a given chain.
-     * @request GET:/v1/chains/{chainId}/addresses/{address}/balances:listErc721
-     * @response `200` `Erc721BalancesDto`
-     */
-    listErc721Balances(chainId, address, query, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}/addresses/${address}/balances:listErc721`, Object.assign(Object.assign({}, query), params), customOptions);
-    }
-    /**
-     * @description Gets a list of transactions where the given wallet address had an on-chain interaction for a given chain. The erc20 transfers, erc721 transfers, and internal transactions returned as part of the native transactions are only those where the address had an interaction. Therefore the transactions returned from this list may not be complete representations of the on-chain data. For a complete view of a transaction use the `/chains/:chainId/transactions/:txHash` endpoint.
-     *
-     * @name ListTransactions
-     * @summary Gets a list of transactions for a wallet address and chain.
-     * @request GET:/v1/chains/{chainId}/addresses/{address}/transactions
-     * @response `200` `ListTransactionDetailsDto`
-     */
-    listTransactions(chainId, address, query, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}/addresses/${address}/transactions`, Object.assign(Object.assign({}, query), params), customOptions);
-    }
-    /**
-     *
-     * @name GetTransaction
-     * @summary Gets the details of a single transaction.
-     * @request GET:/v1/chains/{chainId}/transactions/{txHash}
-     * @response `200` `TransactionDetailsDto`
-     */
-    getTransaction(chainId, txHash, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}/transactions/${txHash}`, params, customOptions);
-    }
-    /**
-     *
-     * @name SupportedChains
-     * @summary Gets the list of chains supported by the api.
-     * @request GET:/v1/chains
-     * @response `200` `ChainsDto`
-     */
-    supportedChains(params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains`, params, customOptions);
-    }
-    /**
-     * No description
-     *
-     * @name GetChainInfo
-     * @summary Gets chain information by chain id.
-     * @request GET:/v1/chains/{chainId}
-     * @response `200` `ChainInfoDto`
-     */
-    getChainInfo(chainId, params = {}, customOptions = {}) {
-        return this.httpClient.get(`/chains/${chainId}`, params, customOptions);
-    }
+class BaseHttpRequest {
+  constructor(config) {
+    this.config = config;
+  }
 }
 
-exports.GlacierClient = GlacierClient;
-//# sourceMappingURL=index.js.map
+class ApiError extends Error {
+  constructor(request, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request;
+  }
+}
+
+class CancelError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+}
+class CancelablePromise {
+  constructor(executor) {
+    this._isResolved = false;
+    this._isRejected = false;
+    this._isCancelled = false;
+    this._cancelHandlers = [];
+    this._promise = new Promise((resolve, reject) => {
+      this._resolve = resolve;
+      this._reject = reject;
+      const onResolve = (value) => {
+        var _a;
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        (_a = this._resolve) == null ? void 0 : _a.call(this, value);
+      };
+      const onReject = (reason) => {
+        var _a;
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        (_a = this._reject) == null ? void 0 : _a.call(this, reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._cancelHandlers.push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => this._isResolved
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => this._isRejected
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => this._isCancelled
+      });
+      return executor(onResolve, onReject, onCancel);
+    });
+  }
+  then(onFulfilled, onRejected) {
+    return this._promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return this._promise.catch(onRejected);
+  }
+  finally(onFinally) {
+    return this._promise.finally(onFinally);
+  }
+  cancel() {
+    var _a;
+    if (this._isResolved || this._isRejected || this._isCancelled) {
+      return;
+    }
+    this._isCancelled = true;
+    if (this._cancelHandlers.length) {
+      try {
+        for (const cancelHandler of this._cancelHandlers) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    this._cancelHandlers.length = 0;
+    (_a = this._reject) == null ? void 0 : _a.call(this, new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
+  }
+}
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+const isString = (value) => {
+  return typeof value === "string";
+};
+const isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+const isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+const isFormData = (value) => {
+  return value instanceof FormData;
+};
+const base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+const getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+const getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    var _a;
+    if ((_a = options.path) == null ? void 0 : _a.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+const getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+const resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+const getHeaders = async (config, options) => {
+  const token = await resolve(options, config.TOKEN);
+  const username = await resolve(options, config.USERNAME);
+  const password = await resolve(options, config.PASSWORD);
+  const additionalHeaders = await resolve(options, config.HEADERS);
+  const headers = Object.entries(__spreadValues(__spreadValues({
+    Accept: "application/json"
+  }, additionalHeaders), options.headers)).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => __spreadProps(__spreadValues({}, headers2), {
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return new Headers(headers);
+};
+const getRequestBody = (options) => {
+  var _a;
+  if (options.body) {
+    if ((_a = options.mediaType) == null ? void 0 : _a.includes("/json")) {
+      return JSON.stringify(options.body);
+    } else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+      return options.body;
+    } else {
+      return JSON.stringify(options.body);
+    }
+  }
+  return void 0;
+};
+const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
+  const controller = new AbortController();
+  const request2 = {
+    headers,
+    body: body != null ? body : formData,
+    method: options.method,
+    signal: controller.signal
+  };
+  if (config.WITH_CREDENTIALS) {
+    request2.credentials = config.CREDENTIALS;
+  }
+  onCancel(() => controller.abort());
+  return await fetch(url, request2);
+};
+const getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers.get(responseHeader);
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+const getResponseBody = async (response) => {
+  if (response.status !== 204) {
+    try {
+      const contentType = response.headers.get("Content-Type");
+      if (contentType) {
+        const isJSON = contentType.toLowerCase().startsWith("application/json");
+        if (isJSON) {
+          return await response.json();
+        } else {
+          return await response.text();
+        }
+      }
+    } catch (error) {
+      console.error(error);
+    }
+  }
+  return void 0;
+};
+const catchErrorCodes = (options, result) => {
+  const errors = __spreadValues({
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable"
+  }, options.errors);
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    throw new ApiError(options, result, "Generic Error");
+  }
+};
+const request = (config, options) => {
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options);
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+        const responseBody = await getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: response.ok,
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader != null ? responseHeader : responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+
+class FetchHttpRequest extends BaseHttpRequest {
+  constructor(config) {
+    super(config);
+  }
+  request(options) {
+    return request(this.config, options);
+  }
+}
+
+class EvmService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getNativeBalance({
+    chainId,
+    address,
+    blockNumber,
+    currency
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:getNative",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "blockNumber": blockNumber,
+        "currency": currency
+      }
+    });
+  }
+  listErc20Balances({
+    chainId,
+    address,
+    blockNumber,
+    pageSize = 10,
+    pageToken,
+    currency
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listErc20",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "blockNumber": blockNumber,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "currency": currency
+      }
+    });
+  }
+  listErc721Balances({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listErc721",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc1155Balances({
+    chainId,
+    address,
+    blockNumber,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listErc1155",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "blockNumber": blockNumber,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listCollectibleBalances({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listCollectibles",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getLatestBlocks({
+    chainId,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/blocks",
+      path: {
+        "chainId": chainId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getBlock({
+    chainId,
+    blockId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/blocks/{blockId}",
+      path: {
+        "chainId": chainId,
+        "blockId": blockId
+      }
+    });
+  }
+  getDeploymentTransaction({
+    chainId,
+    address,
+    currency
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/contracts/{address}/transactions:getDeployment",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "currency": currency
+      }
+    });
+  }
+  supportedChains() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains"
+    });
+  }
+  getChainInfo({
+    chainId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}",
+      path: {
+        "chainId": chainId
+      }
+    });
+  }
+  reindexNft({
+    chainId,
+    address,
+    tokenId
+  }) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}/tokens/{tokenId}:reindex",
+      path: {
+        "chainId": chainId,
+        "address": address,
+        "tokenId": tokenId
+      }
+    });
+  }
+  getCollection({
+    chainId,
+    address,
+    timeframe
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "timeframe": timeframe
+      }
+    });
+  }
+  listListingsByCollectionTokenId({
+    chainId,
+    address,
+    tokenId,
+    pageSize = 10,
+    pageToken,
+    sortBy,
+    sortOrder,
+    currency,
+    includeHistory = false
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}/tokens/{tokenId}/listings",
+      path: {
+        "chainId": chainId,
+        "address": address,
+        "tokenId": tokenId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortBy": sortBy,
+        "sortOrder": sortOrder,
+        "currency": currency,
+        "includeHistory": includeHistory
+      }
+    });
+  }
+  listListingsByCollection({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken,
+    sortBy,
+    sortOrder,
+    currency,
+    includeHistory = false
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}/listings",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortBy": sortBy,
+        "sortOrder": sortOrder,
+        "currency": currency,
+        "includeHistory": includeHistory
+      }
+    });
+  }
+  listRecentListings({
+    chainId,
+    pageSize = 10,
+    pageToken,
+    eventType,
+    currency
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/listings",
+      path: {
+        "chainId": chainId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "eventType": eventType,
+        "currency": currency
+      }
+    });
+  }
+  listCollections({
+    chainId,
+    pageSize = 10,
+    pageToken,
+    timeframe,
+    sortBy,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections",
+      path: {
+        "chainId": chainId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "timeframe": timeframe,
+        "sortBy": sortBy,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  search({
+    chainId,
+    requestBody
+  }) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/chains/{chainId}/nfts/search",
+      path: {
+        "chainId": chainId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  getTokenMetadata({
+    chainId,
+    address,
+    tokenId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}/tokens/{tokenId}",
+      path: {
+        "chainId": chainId,
+        "address": address,
+        "tokenId": tokenId
+      }
+    });
+  }
+  listTransfers({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/tokens/{address}/transfers",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listTransactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken,
+    startBlock,
+    endBlock,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listNativeTransactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listNative",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc20Transactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc20",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc721Transactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc721",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc1155Transactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc1155",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listInternalTransactions({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listInternals",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getTransaction({
+    chainId,
+    txHash
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/transactions/{txHash}",
+      path: {
+        "chainId": chainId,
+        "txHash": txHash
+      }
+    });
+  }
+  getTransactionsForBlock({
+    chainId,
+    blockId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/blocks/{blockId}/transactions",
+      path: {
+        "chainId": chainId,
+        "blockId": blockId
+      }
+    });
+  }
+  listLatestTransactions({
+    chainId,
+    pageSize = 10,
+    pageToken,
+    status
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/transactions",
+      path: {
+        "chainId": chainId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "status": status
+      }
+    });
+  }
+}
+
+class HealthCheckService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  healthCheck() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/health-check",
+      errors: {
+        503: `The Health Check is not successful`
+      }
+    });
+  }
+}
+
+class OperationsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  postTransactionExportJob({
+    requestBody
+  }) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/operations/transactions:export",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  getOperationResult({
+    operationId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/operations/{operationId}",
+      path: {
+        "operationId": operationId
+      }
+    });
+  }
+}
+
+class PrimaryNetworkService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getTxByHash({
+    blockchainId,
+    network,
+    txHash
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/transactions/{txHash}",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network,
+        "txHash": txHash
+      }
+    });
+  }
+  listLatestPrimaryNetworkTransactions({
+    blockchainId,
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/transactions",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "addresses": addresses,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listActivePrimaryNetworkStakingTransactions({
+    blockchainId,
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/transactions:listStaking",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "addresses": addresses,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  getUtxosByAddresses({
+    blockchainId,
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    assetId,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/utxos",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "addresses": addresses,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "assetId": assetId,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  getBalancesByAddresses({
+    blockchainId,
+    network,
+    blockTimestamp,
+    addresses
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/balances",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "blockTimestamp": blockTimestamp,
+        "addresses": addresses
+      }
+    });
+  }
+  getBlockById({
+    blockchainId,
+    network,
+    blockId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/blocks/{blockId}",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network,
+        "blockId": blockId
+      }
+    });
+  }
+  listPrimaryNetworkBlocksByNodeId({
+    blockchainId,
+    network,
+    nodeId,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/nodes/{nodeId}/blocks",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network,
+        "nodeId": nodeId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listLatestPrimaryNetworkBlocks({
+    blockchainId,
+    network,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/blocks",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listLatestXChainVertices({
+    blockchainId,
+    network,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/vertices",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getVertexByHash({
+    vertexHash,
+    blockchainId,
+    network
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/vertices/{vertexHash}",
+      path: {
+        "vertexHash": vertexHash,
+        "blockchainId": blockchainId,
+        "network": network
+      }
+    });
+  }
+  getVertexByHeight({
+    vertexHeight,
+    blockchainId,
+    network,
+    pageSize = 10,
+    pageToken,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/vertices:listByHeight",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network
+      },
+      query: {
+        "vertexHeight": vertexHeight,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  getAssetDetails({
+    blockchainId,
+    network,
+    assetId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/assets/{assetId}",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network,
+        "assetId": assetId
+      }
+    });
+  }
+  getAssetTransactions({
+    blockchainId,
+    network,
+    assetId,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains/{blockchainId}/assets/{assetId}/transactions",
+      path: {
+        "blockchainId": blockchainId,
+        "network": network,
+        "assetId": assetId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getChainAddresses({
+    addresses,
+    network
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/addresses:listChainIds",
+      path: {
+        "network": network
+      },
+      query: {
+        "addresses": addresses
+      }
+    });
+  }
+}
+
+class Glacier {
+  constructor(config, HttpRequest = FetchHttpRequest) {
+    var _a, _b, _c, _d;
+    this.request = new HttpRequest({
+      BASE: (_a = config == null ? void 0 : config.BASE) != null ? _a : "",
+      VERSION: (_b = config == null ? void 0 : config.VERSION) != null ? _b : "Beta",
+      WITH_CREDENTIALS: (_c = config == null ? void 0 : config.WITH_CREDENTIALS) != null ? _c : false,
+      CREDENTIALS: (_d = config == null ? void 0 : config.CREDENTIALS) != null ? _d : "include",
+      TOKEN: config == null ? void 0 : config.TOKEN,
+      USERNAME: config == null ? void 0 : config.USERNAME,
+      PASSWORD: config == null ? void 0 : config.PASSWORD,
+      HEADERS: config == null ? void 0 : config.HEADERS,
+      ENCODE_PATH: config == null ? void 0 : config.ENCODE_PATH
+    });
+    this.evm = new EvmService(this.request);
+    this.healthCheck = new HealthCheckService(this.request);
+    this.operations = new OperationsService(this.request);
+    this.primaryNetwork = new PrimaryNetworkService(this.request);
+  }
+}
+
+const OpenAPI = {
+  BASE: "",
+  VERSION: "Beta",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+var BlockchainId = /* @__PURE__ */ ((BlockchainId2) => {
+  BlockchainId2["P_CHAIN"] = "p-chain";
+  BlockchainId2["X_CHAIN"] = "x-chain";
+  BlockchainId2["C_CHAIN"] = "c-chain";
+  BlockchainId2["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  BlockchainId2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  return BlockchainId2;
+})(BlockchainId || {});
+
+var BlockchainIds = /* @__PURE__ */ ((BlockchainIds2) => {
+  BlockchainIds2["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  BlockchainIds2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  BlockchainIds2["_2Q9E4R6MU3U68N_U1F_YJGB_R6JVWR_RX36COHP_AX5UQXSE55X1Q5"] = "2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5";
+  BlockchainIds2["_2JVSBOINJ9C2J33VNTVZ_YT_VJNZD_N2NKIWW_KJCUM_HUWEB5DB_BRM"] = "2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm";
+  BlockchainIds2["Y_H8D7TH_NJKXMTKUV2JG_BA4P1RN3QPR4P_PR7QYNFCDO_S6K6HWP"] = "yH8D7ThNJkxmtkuv2jgBa4P1Rn3Qpr4pPr7QYNfcdoS6k6HWp";
+  return BlockchainIds2;
+})(BlockchainIds || {});
+
+exports.CChainExportTransaction = void 0;
+((CChainExportTransaction2) => {
+  ((txType2) => {
+    txType2["EXPORT_TX"] = "ExportTx";
+  })(CChainExportTransaction2.txType || (CChainExportTransaction2.txType = {}));
+})(exports.CChainExportTransaction || (exports.CChainExportTransaction = {}));
+
+exports.CChainImportTransaction = void 0;
+((CChainImportTransaction2) => {
+  ((txType2) => {
+    txType2["IMPORT_TX"] = "ImportTx";
+  })(CChainImportTransaction2.txType || (CChainImportTransaction2.txType = {}));
+})(exports.CChainImportTransaction || (exports.CChainImportTransaction = {}));
+
+var ChainStatus = /* @__PURE__ */ ((ChainStatus2) => {
+  ChainStatus2["OK"] = "OK";
+  ChainStatus2["UNAVAILABLE"] = "UNAVAILABLE";
+  return ChainStatus2;
+})(ChainStatus || {});
+
+var CollectionSortByOption = /* @__PURE__ */ ((CollectionSortByOption2) => {
+  CollectionSortByOption2["SALE_TIMESTAMP"] = "saleTimestamp";
+  CollectionSortByOption2["VOLUME"] = "volume";
+  CollectionSortByOption2["VOLUME_CHANGE"] = "volumeChange";
+  CollectionSortByOption2["FLOOR_PRICE"] = "floorPrice";
+  return CollectionSortByOption2;
+})(CollectionSortByOption || {});
+
+exports.CreateEvmTransactionExportRequest = void 0;
+((CreateEvmTransactionExportRequest2) => {
+  ((type2) => {
+    type2["TRANSACTION_EXPORT_EVM"] = "TRANSACTION_EXPORT_EVM";
+  })(CreateEvmTransactionExportRequest2.type || (CreateEvmTransactionExportRequest2.type = {}));
+})(exports.CreateEvmTransactionExportRequest || (exports.CreateEvmTransactionExportRequest = {}));
+
+exports.CreatePrimaryNetworkTransactionExportRequest = void 0;
+((CreatePrimaryNetworkTransactionExportRequest2) => {
+  ((type2) => {
+    type2["TRANSACTION_EXPORT_PRIMARY_NETWORK"] = "TRANSACTION_EXPORT_PRIMARY_NETWORK";
+  })(CreatePrimaryNetworkTransactionExportRequest2.type || (CreatePrimaryNetworkTransactionExportRequest2.type = {}));
+})(exports.CreatePrimaryNetworkTransactionExportRequest || (exports.CreatePrimaryNetworkTransactionExportRequest = {}));
+
+var CurrencyCode = /* @__PURE__ */ ((CurrencyCode2) => {
+  CurrencyCode2["USD"] = "usd";
+  CurrencyCode2["EUR"] = "eur";
+  CurrencyCode2["AUD"] = "aud";
+  CurrencyCode2["CAD"] = "cad";
+  CurrencyCode2["CHF"] = "chf";
+  CurrencyCode2["CLP"] = "clp";
+  CurrencyCode2["CNY"] = "cny";
+  CurrencyCode2["CZK"] = "czk";
+  CurrencyCode2["DKK"] = "dkk";
+  CurrencyCode2["GBP"] = "gbp";
+  CurrencyCode2["HKD"] = "hkd";
+  CurrencyCode2["HUF"] = "huf";
+  CurrencyCode2["JPY"] = "jpy";
+  CurrencyCode2["NZD"] = "nzd";
+  return CurrencyCode2;
+})(CurrencyCode || {});
+
+exports.Erc1155Token = void 0;
+((Erc1155Token2) => {
+  ((ercType2) => {
+    ercType2["ERC_1155"] = "ERC-1155";
+  })(Erc1155Token2.ercType || (Erc1155Token2.ercType = {}));
+})(exports.Erc1155Token || (exports.Erc1155Token = {}));
+
+exports.Erc1155TokenBalance = void 0;
+((Erc1155TokenBalance2) => {
+  ((ercType2) => {
+    ercType2["ERC_1155"] = "ERC-1155";
+  })(Erc1155TokenBalance2.ercType || (Erc1155TokenBalance2.ercType = {}));
+})(exports.Erc1155TokenBalance || (exports.Erc1155TokenBalance = {}));
+
+exports.Erc20Token = void 0;
+((Erc20Token2) => {
+  ((ercType2) => {
+    ercType2["ERC_20"] = "ERC-20";
+  })(Erc20Token2.ercType || (Erc20Token2.ercType = {}));
+})(exports.Erc20Token || (exports.Erc20Token = {}));
+
+exports.Erc20TokenBalance = void 0;
+((Erc20TokenBalance2) => {
+  ((ercType2) => {
+    ercType2["ERC_20"] = "ERC-20";
+  })(Erc20TokenBalance2.ercType || (Erc20TokenBalance2.ercType = {}));
+})(exports.Erc20TokenBalance || (exports.Erc20TokenBalance = {}));
+
+exports.Erc721Token = void 0;
+((Erc721Token2) => {
+  ((ercType2) => {
+    ercType2["ERC_721"] = "ERC-721";
+  })(Erc721Token2.ercType || (Erc721Token2.ercType = {}));
+})(exports.Erc721Token || (exports.Erc721Token = {}));
+
+exports.Erc721TokenBalance = void 0;
+((Erc721TokenBalance2) => {
+  ((ercType2) => {
+    ercType2["ERC_721"] = "ERC-721";
+  })(Erc721TokenBalance2.ercType || (Erc721TokenBalance2.ercType = {}));
+})(exports.Erc721TokenBalance || (exports.Erc721TokenBalance = {}));
+
+var ErcType = /* @__PURE__ */ ((ErcType2) => {
+  ErcType2["ERC_20"] = "ERC-20";
+  ErcType2["ERC_721"] = "ERC-721";
+  ErcType2["ERC_1155"] = "ERC-1155";
+  ErcType2["UNKNOWN"] = "UNKNOWN";
+  return ErcType2;
+})(ErcType || {});
+
+var InternalTransactionOpCall = /* @__PURE__ */ ((InternalTransactionOpCall2) => {
+  InternalTransactionOpCall2["UNKNOWN"] = "UNKNOWN";
+  InternalTransactionOpCall2["CALL"] = "CALL";
+  InternalTransactionOpCall2["CREATE"] = "CREATE";
+  InternalTransactionOpCall2["CREATE2"] = "CREATE2";
+  InternalTransactionOpCall2["CALLCODE"] = "CALLCODE";
+  InternalTransactionOpCall2["DELEGATECALL"] = "DELEGATECALL";
+  InternalTransactionOpCall2["STATICCALL"] = "STATICCALL";
+  return InternalTransactionOpCall2;
+})(InternalTransactionOpCall || {});
+
+var ListingCurrencyType = /* @__PURE__ */ ((ListingCurrencyType2) => {
+  ListingCurrencyType2["NATIVE"] = "NATIVE";
+  ListingCurrencyType2["ERC20"] = "ERC20";
+  return ListingCurrencyType2;
+})(ListingCurrencyType || {});
+
+var ListingEventType = /* @__PURE__ */ ((ListingEventType2) => {
+  ListingEventType2["OPEN_LISTING"] = "OPEN_LISTING";
+  ListingEventType2["CANCEL_LISTING"] = "CANCEL_LISTING";
+  ListingEventType2["PURCHASE_LISTING"] = "PURCHASE_LISTING";
+  ListingEventType2["CLOSE_AUCTION"] = "CLOSE_AUCTION";
+  return ListingEventType2;
+})(ListingEventType || {});
+
+var ListingsSortByOption = /* @__PURE__ */ ((ListingsSortByOption2) => {
+  ListingsSortByOption2["LAST_EVENT_TIMESTAMP"] = "lastEventTimestamp";
+  return ListingsSortByOption2;
+})(ListingsSortByOption || {});
+
+var ListingType = /* @__PURE__ */ ((ListingType2) => {
+  ListingType2["SALE"] = "SALE";
+  ListingType2["AUCTION"] = "AUCTION";
+  return ListingType2;
+})(ListingType || {});
+
+var Network = /* @__PURE__ */ ((Network2) => {
+  Network2["MAINNET"] = "mainnet";
+  Network2["FUJI"] = "fuji";
+  return Network2;
+})(Network || {});
+
+var NftSearchResultTypeOption = /* @__PURE__ */ ((NftSearchResultTypeOption2) => {
+  NftSearchResultTypeOption2["TOKEN"] = "token";
+  NftSearchResultTypeOption2["COLLECTION"] = "collection";
+  return NftSearchResultTypeOption2;
+})(NftSearchResultTypeOption || {});
+
+var NftTokenMetadataStatus = /* @__PURE__ */ ((NftTokenMetadataStatus2) => {
+  NftTokenMetadataStatus2["UNKNOWN"] = "UNKNOWN";
+  NftTokenMetadataStatus2["MISSING_TOKEN"] = "MISSING_TOKEN";
+  NftTokenMetadataStatus2["INVALID_TOKEN_URI"] = "INVALID_TOKEN_URI";
+  NftTokenMetadataStatus2["INVALID_TOKEN_URI_SCHEME"] = "INVALID_TOKEN_URI_SCHEME";
+  NftTokenMetadataStatus2["UNREACHABLE_TOKEN_URI"] = "UNREACHABLE_TOKEN_URI";
+  NftTokenMetadataStatus2["THROTTLED_TOKEN_URI"] = "THROTTLED_TOKEN_URI";
+  NftTokenMetadataStatus2["METADATA_CONTENT_TOO_LARGE"] = "METADATA_CONTENT_TOO_LARGE";
+  NftTokenMetadataStatus2["INVALID_METADATA"] = "INVALID_METADATA";
+  NftTokenMetadataStatus2["INVALID_METADATA_JSON"] = "INVALID_METADATA_JSON";
+  NftTokenMetadataStatus2["INDEXED"] = "INDEXED";
+  NftTokenMetadataStatus2["UNINDEXED"] = "UNINDEXED";
+  return NftTokenMetadataStatus2;
+})(NftTokenMetadataStatus || {});
+
+var OperationStatus = /* @__PURE__ */ ((OperationStatus2) => {
+  OperationStatus2["RUNNING"] = "RUNNING";
+  OperationStatus2["COMPLETED"] = "COMPLETED";
+  OperationStatus2["COMPLETED_WITH_WARNING"] = "COMPLETED_WITH_WARNING";
+  OperationStatus2["FAILED"] = "FAILED";
+  return OperationStatus2;
+})(OperationStatus || {});
+
+var OperationStatusCode = /* @__PURE__ */ ((OperationStatusCode2) => {
+  OperationStatusCode2["ERR_INVALID_REQUEST"] = "ErrInvalidRequest";
+  OperationStatusCode2["ERR_INTERNAL"] = "ErrInternal";
+  OperationStatusCode2["WARN_TRUNCATED_EXPORT"] = "WarnTruncatedExport";
+  return OperationStatusCode2;
+})(OperationStatusCode || {});
+
+var OperationType = /* @__PURE__ */ ((OperationType2) => {
+  OperationType2["TRANSACTION_EXPORT_EVM"] = "TRANSACTION_EXPORT_EVM";
+  OperationType2["TRANSACTION_EXPORT_PRIMARY_NETWORK"] = "TRANSACTION_EXPORT_PRIMARY_NETWORK";
+  return OperationType2;
+})(OperationType || {});
+
+var PChainId = /* @__PURE__ */ ((PChainId2) => {
+  PChainId2["P_CHAIN"] = "p-chain";
+  PChainId2["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  return PChainId2;
+})(PChainId || {});
+
+var PChainTransactionType = /* @__PURE__ */ ((PChainTransactionType2) => {
+  PChainTransactionType2["ADD_VALIDATOR_TX"] = "AddValidatorTx";
+  PChainTransactionType2["ADD_DELEGATOR_TX"] = "AddDelegatorTx";
+  PChainTransactionType2["ADD_PERMISSIONLESS_VALIDATOR_TX"] = "AddPermissionlessValidatorTx";
+  PChainTransactionType2["ADD_SUBNET_VALIDATOR_TX"] = "AddSubnetValidatorTx";
+  PChainTransactionType2["REMOVE_SUBNET_VALIDATOR_TX"] = "RemoveSubnetValidatorTx";
+  PChainTransactionType2["REWARD_VALIDATOR_TX"] = "RewardValidatorTx";
+  PChainTransactionType2["CREATE_CHAIN_TX"] = "CreateChainTx";
+  PChainTransactionType2["CREATE_SUBNET_TX"] = "CreateSubnetTx";
+  PChainTransactionType2["IMPORT_TX"] = "ImportTx";
+  PChainTransactionType2["EXPORT_TX"] = "ExportTx";
+  PChainTransactionType2["ADVANCE_TIME_TX"] = "AdvanceTimeTx";
+  PChainTransactionType2["UNKNOWN"] = "UNKNOWN";
+  return PChainTransactionType2;
+})(PChainTransactionType || {});
+
+var PrimaryNetwork = /* @__PURE__ */ ((PrimaryNetwork2) => {
+  PrimaryNetwork2["MAINNET"] = "mainnet";
+  PrimaryNetwork2["FUJI"] = "fuji";
+  return PrimaryNetwork2;
+})(PrimaryNetwork || {});
+
+var PrimaryNetworkChainName = /* @__PURE__ */ ((PrimaryNetworkChainName2) => {
+  PrimaryNetworkChainName2["X_CHAIN"] = "x-chain";
+  PrimaryNetworkChainName2["P_CHAIN"] = "p-chain";
+  PrimaryNetworkChainName2["C_CHAIN"] = "c-chain";
+  return PrimaryNetworkChainName2;
+})(PrimaryNetworkChainName || {});
+
+var ResourceLinkType = /* @__PURE__ */ ((ResourceLinkType2) => {
+  ResourceLinkType2["BLOG"] = "Blog";
+  ResourceLinkType2["COIN_GECKO"] = "CoinGecko";
+  ResourceLinkType2["COIN_MARKET_CAP"] = "CoinMarketCap";
+  ResourceLinkType2["DISCORD"] = "Discord";
+  ResourceLinkType2["DOCUMENTATION"] = "Documentation";
+  ResourceLinkType2["FACEBOOK"] = "Facebook";
+  ResourceLinkType2["GITHUB"] = "Github";
+  ResourceLinkType2["INSTAGRAM"] = "Instagram";
+  ResourceLinkType2["LINKED_IN"] = "LinkedIn";
+  ResourceLinkType2["MEDIUM"] = "Medium";
+  ResourceLinkType2["REDDIT"] = "Reddit";
+  ResourceLinkType2["SUPPORT"] = "Support";
+  ResourceLinkType2["TELEGRAM"] = "Telegram";
+  ResourceLinkType2["TIK_TOK"] = "TikTok";
+  ResourceLinkType2["TWITTER"] = "Twitter";
+  ResourceLinkType2["WEBSITE"] = "Website";
+  ResourceLinkType2["WHITEPAPER"] = "Whitepaper";
+  ResourceLinkType2["YOUTUBE"] = "Youtube";
+  return ResourceLinkType2;
+})(ResourceLinkType || {});
+
+var RewardType = /* @__PURE__ */ ((RewardType2) => {
+  RewardType2["VALIDATOR"] = "VALIDATOR";
+  RewardType2["DELEGATOR"] = "DELEGATOR";
+  return RewardType2;
+})(RewardType || {});
+
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "asc";
+  SortOrder2["DESC"] = "desc";
+  return SortOrder2;
+})(SortOrder || {});
+
+var TransactionMethodType = /* @__PURE__ */ ((TransactionMethodType2) => {
+  TransactionMethodType2["NATIVE_TRANSFER"] = "NATIVE_TRANSFER";
+  TransactionMethodType2["CONTRACT_CALL"] = "CONTRACT_CALL";
+  TransactionMethodType2["CONTRACT_CREATION"] = "CONTRACT_CREATION";
+  return TransactionMethodType2;
+})(TransactionMethodType || {});
+
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["FAILED"] = "failed";
+  TransactionStatus2["SUCCESS"] = "success";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+
+var TrendingTimeframe = /* @__PURE__ */ ((TrendingTimeframe2) => {
+  TrendingTimeframe2["DAY"] = "day";
+  TrendingTimeframe2["WEEK"] = "week";
+  TrendingTimeframe2["MONTH"] = "month";
+  return TrendingTimeframe2;
+})(TrendingTimeframe || {});
+
+var UtxoType = /* @__PURE__ */ ((UtxoType2) => {
+  UtxoType2["STAKE"] = "STAKE";
+  UtxoType2["TRANSFER"] = "TRANSFER";
+  return UtxoType2;
+})(UtxoType || {});
+
+var VmName = /* @__PURE__ */ ((VmName2) => {
+  VmName2["EVM"] = "EVM";
+  VmName2["BITCOIN"] = "BITCOIN";
+  VmName2["ETHEREUM"] = "ETHEREUM";
+  return VmName2;
+})(VmName || {});
+
+var XChainId = /* @__PURE__ */ ((XChainId2) => {
+  XChainId2["X_CHAIN"] = "x-chain";
+  XChainId2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  return XChainId2;
+})(XChainId || {});
+
+exports.XChainLinearTransaction = void 0;
+((XChainLinearTransaction2) => {
+  ((chainFormat2) => {
+    chainFormat2["NON_LINEAR"] = "non-linear";
+    chainFormat2["LINEAR"] = "linear";
+  })(XChainLinearTransaction2.chainFormat || (XChainLinearTransaction2.chainFormat = {}));
+})(exports.XChainLinearTransaction || (exports.XChainLinearTransaction = {}));
+
+exports.XChainNonLinearTransaction = void 0;
+((XChainNonLinearTransaction2) => {
+  ((chainFormat2) => {
+    chainFormat2["NON_LINEAR"] = "non-linear";
+    chainFormat2["LINEAR"] = "linear";
+  })(XChainNonLinearTransaction2.chainFormat || (XChainNonLinearTransaction2.chainFormat = {}));
+})(exports.XChainNonLinearTransaction || (exports.XChainNonLinearTransaction = {}));
+
+exports.ApiError = ApiError;
+exports.BaseHttpRequest = BaseHttpRequest;
+exports.BlockchainId = BlockchainId;
+exports.BlockchainIds = BlockchainIds;
+exports.CancelError = CancelError;
+exports.CancelablePromise = CancelablePromise;
+exports.ChainStatus = ChainStatus;
+exports.CollectionSortByOption = CollectionSortByOption;
+exports.CurrencyCode = CurrencyCode;
+exports.ErcType = ErcType;
+exports.EvmService = EvmService;
+exports.Glacier = Glacier;
+exports.HealthCheckService = HealthCheckService;
+exports.InternalTransactionOpCall = InternalTransactionOpCall;
+exports.ListingCurrencyType = ListingCurrencyType;
+exports.ListingEventType = ListingEventType;
+exports.ListingType = ListingType;
+exports.ListingsSortByOption = ListingsSortByOption;
+exports.Network = Network;
+exports.NftSearchResultTypeOption = NftSearchResultTypeOption;
+exports.NftTokenMetadataStatus = NftTokenMetadataStatus;
+exports.OpenAPI = OpenAPI;
+exports.OperationStatus = OperationStatus;
+exports.OperationStatusCode = OperationStatusCode;
+exports.OperationType = OperationType;
+exports.OperationsService = OperationsService;
+exports.PChainId = PChainId;
+exports.PChainTransactionType = PChainTransactionType;
+exports.PrimaryNetwork = PrimaryNetwork;
+exports.PrimaryNetworkChainName = PrimaryNetworkChainName;
+exports.PrimaryNetworkService = PrimaryNetworkService;
+exports.ResourceLinkType = ResourceLinkType;
+exports.RewardType = RewardType;
+exports.SortOrder = SortOrder;
+exports.TransactionMethodType = TransactionMethodType;
+exports.TransactionStatus = TransactionStatus;
+exports.TrendingTimeframe = TrendingTimeframe;
+exports.UtxoType = UtxoType;
+exports.VmName = VmName;
+exports.XChainId = XChainId;