@avalabs/glacier-sdk 2.8.0-alpha.15 → 2.8.0-alpha.151

package/dist/index.js

@@ -1,157 +1,2032 @@
 '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);
-    }
-}
-
-exports.GlacierClient = GlacierClient;
-//# sourceMappingURL=index.js.map
+class BaseHttpRequest {
+  constructor(config) {
+    this.config = config;
+  }
+}
+
+class ApiError extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
+  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 {
+  [Symbol.toStringTag];
+  _isResolved;
+  _isRejected;
+  _isCancelled;
+  _cancelHandlers;
+  _promise;
+  _resolve;
+  _reject;
+  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) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isResolved = true;
+        this._resolve?.(value);
+      };
+      const onReject = (reason) => {
+        if (this._isResolved || this._isRejected || this._isCancelled) {
+          return;
+        }
+        this._isRejected = true;
+        this._reject?.(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() {
+    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;
+    this._reject?.(new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return this._isCancelled;
+  }
+}
+
+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) => {
+    if (options.path?.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({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...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) => {
+  if (options.body) {
+    if (options.mediaType?.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 ?? 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 = {
+    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 ?? 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 DefaultService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  mediaControllerUploadImage() {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/media/uploadImage"
+    });
+  }
+  registerWebhook({
+    requestBody
+  }) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/webhooks",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  listWebhooks({
+    pageSize = 10,
+    pageToken,
+    status
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/webhooks",
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "status": status
+      }
+    });
+  }
+  deactivateWebhook({
+    id
+  }) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/v1/webhooks/{id}",
+      path: {
+        "id": id
+      }
+    });
+  }
+}
+
+class EvmBalancesService {
+  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,
+    contractAddresses,
+    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,
+        "contractAddresses": contractAddresses,
+        "currency": currency
+      }
+    });
+  }
+  listErc721Balances({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken,
+    contractAddress
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listErc721",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "contractAddress": contractAddress
+      }
+    });
+  }
+  listErc1155Balances({
+    chainId,
+    address,
+    blockNumber,
+    pageSize = 10,
+    pageToken,
+    contractAddress
+  }) {
+    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,
+        "contractAddress": contractAddress
+      }
+    });
+  }
+  listCollectibleBalances({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken,
+    contractAddress
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/balances:listCollectibles",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "contractAddress": contractAddress
+      }
+    });
+  }
+}
+
+class EvmBlocksService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+}
+
+class EvmChainsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  supportedChains({
+    network
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains",
+      query: {
+        "network": network
+      }
+    });
+  }
+  getChainInfo({
+    chainId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}",
+      path: {
+        "chainId": chainId
+      }
+    });
+  }
+}
+
+class EvmContractsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getContractMetadata({
+    chainId,
+    address
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}",
+      path: {
+        "chainId": chainId,
+        "address": address
+      }
+    });
+  }
+  updateContractInfo({
+    chainId,
+    address,
+    requestBody
+  }) {
+    return this.httpRequest.request({
+      method: "PATCH",
+      url: "/v1/chains/{chainId}/contracts/{address}",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+}
+
+class EvmTransactionsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+  listContractDeployments({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/contracts/{address}/deployments",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listTransfers({
+    chainId,
+    address,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/tokens/{address}/transfers",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "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,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listNative",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc20Transactions({
+    chainId,
+    address,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc20",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc721Transactions({
+    chainId,
+    address,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc721",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listErc1155Transactions({
+    chainId,
+    address,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listErc1155",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  listInternalTransactions({
+    chainId,
+    address,
+    startBlock,
+    endBlock,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/addresses/{address}/transactions:listInternals",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "startBlock": startBlock,
+        "endBlock": endBlock,
+        "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 NfTsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+  listTokens({
+    chainId,
+    address,
+    pageSize = 10,
+    pageToken
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/chains/{chainId}/nfts/collections/{address}/tokens",
+      path: {
+        "chainId": chainId,
+        "address": address
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+  getTokenDetails({
+    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
+      }
+    });
+  }
+}
+
+class OperationsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getOperationResult({
+    operationId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/operations/{operationId}",
+      path: {
+        "operationId": operationId
+      }
+    });
+  }
+  postTransactionExportJob({
+    requestBody
+  }) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/v1/operations/transactions:export",
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+}
+
+class PrimaryNetworkService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+  getChainIdsForAddresses({
+    addresses,
+    network
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/addresses:listChainIds",
+      path: {
+        "network": network
+      },
+      query: {
+        "addresses": addresses
+      }
+    });
+  }
+  getNetworkDetails({
+    network
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}",
+      path: {
+        "network": network
+      }
+    });
+  }
+  listBlockchains({
+    network,
+    pageSize = 10,
+    pageToken,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/blockchains",
+      path: {
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listSubnets({
+    network,
+    pageSize = 10,
+    pageToken,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/subnets",
+      path: {
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listValidators({
+    network,
+    pageSize = 10,
+    pageToken,
+    minTimeRemaining,
+    maxTimeRemaining,
+    minDelegationCapacity,
+    maxDelegationCapacity,
+    minFeePercentage,
+    maxFeePercentage,
+    nodeIds,
+    sortOrder,
+    validationStatus,
+    subnetId
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/validators",
+      path: {
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "minTimeRemaining": minTimeRemaining,
+        "maxTimeRemaining": maxTimeRemaining,
+        "minDelegationCapacity": minDelegationCapacity,
+        "maxDelegationCapacity": maxDelegationCapacity,
+        "minFeePercentage": minFeePercentage,
+        "maxFeePercentage": maxFeePercentage,
+        "nodeIds": nodeIds,
+        "sortOrder": sortOrder,
+        "validationStatus": validationStatus,
+        "subnetId": subnetId
+      }
+    });
+  }
+  getSingleValidatorDetails({
+    network,
+    nodeId,
+    pageSize = 10,
+    pageToken,
+    sortOrder,
+    validationStatus
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/validators/{nodeId}",
+      path: {
+        "network": network,
+        "nodeId": nodeId
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder,
+        "validationStatus": validationStatus
+      }
+    });
+  }
+  listDelegators({
+    network,
+    pageSize = 10,
+    pageToken,
+    rewardAddresses,
+    sortOrder,
+    delegationStatus,
+    nodeIds
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/delegators",
+      path: {
+        "network": network
+      },
+      query: {
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "rewardAddresses": rewardAddresses,
+        "sortOrder": sortOrder,
+        "delegationStatus": delegationStatus,
+        "nodeIds": nodeIds
+      }
+    });
+  }
+}
+
+class PrimaryNetworkBalancesService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+}
+
+class PrimaryNetworkBlocksService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+}
+
+class PrimaryNetworkRewardsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  listPendingPrimaryNetworkRewards({
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    nodeIds,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/rewards:listPending",
+      path: {
+        "network": network
+      },
+      query: {
+        "addresses": addresses,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "nodeIds": nodeIds,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listHistoricalPrimaryNetworkRewards({
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    nodeIds,
+    sortOrder
+  }) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/v1/networks/{network}/rewards",
+      path: {
+        "network": network
+      },
+      query: {
+        "addresses": addresses,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "nodeIds": nodeIds,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+}
+
+class PrimaryNetworkTransactionsService {
+  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,
+    txTypes,
+    startTimestamp,
+    endTimestamp,
+    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,
+        "txTypes": txTypes,
+        "startTimestamp": startTimestamp,
+        "endTimestamp": endTimestamp,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listActivePrimaryNetworkStakingTransactions({
+    blockchainId,
+    network,
+    addresses,
+    txTypes,
+    startTimestamp,
+    endTimestamp,
+    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,
+        "txTypes": txTypes,
+        "startTimestamp": startTimestamp,
+        "endTimestamp": endTimestamp,
+        "pageSize": pageSize,
+        "pageToken": pageToken,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+  listAssetTransactions({
+    blockchainId,
+    network,
+    assetId,
+    txTypes,
+    startTimestamp,
+    endTimestamp,
+    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: {
+        "txTypes": txTypes,
+        "startTimestamp": startTimestamp,
+        "endTimestamp": endTimestamp,
+        "pageSize": pageSize,
+        "pageToken": pageToken
+      }
+    });
+  }
+}
+
+class PrimaryNetworkUtxOsService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getUtxosByAddresses({
+    blockchainId,
+    network,
+    addresses,
+    pageSize = 10,
+    pageToken,
+    assetId,
+    includeSpent,
+    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,
+        "includeSpent": includeSpent,
+        "sortOrder": sortOrder
+      }
+    });
+  }
+}
+
+class PrimaryNetworkVerticesService {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  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
+      }
+    });
+  }
+}
+
+class Glacier {
+  default;
+  evmBalances;
+  evmBlocks;
+  evmChains;
+  evmContracts;
+  evmTransactions;
+  healthCheck;
+  nfTs;
+  operations;
+  primaryNetwork;
+  primaryNetworkBalances;
+  primaryNetworkBlocks;
+  primaryNetworkRewards;
+  primaryNetworkTransactions;
+  primaryNetworkUtxOs;
+  primaryNetworkVertices;
+  request;
+  constructor(config, HttpRequest = FetchHttpRequest) {
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? "https://glacier-api-dev.avax.network",
+      VERSION: config?.VERSION ?? "Beta",
+      WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
+      CREDENTIALS: config?.CREDENTIALS ?? "include",
+      TOKEN: config?.TOKEN,
+      USERNAME: config?.USERNAME,
+      PASSWORD: config?.PASSWORD,
+      HEADERS: config?.HEADERS,
+      ENCODE_PATH: config?.ENCODE_PATH
+    });
+    this.default = new DefaultService(this.request);
+    this.evmBalances = new EvmBalancesService(this.request);
+    this.evmBlocks = new EvmBlocksService(this.request);
+    this.evmChains = new EvmChainsService(this.request);
+    this.evmContracts = new EvmContractsService(this.request);
+    this.evmTransactions = new EvmTransactionsService(this.request);
+    this.healthCheck = new HealthCheckService(this.request);
+    this.nfTs = new NfTsService(this.request);
+    this.operations = new OperationsService(this.request);
+    this.primaryNetwork = new PrimaryNetworkService(this.request);
+    this.primaryNetworkBalances = new PrimaryNetworkBalancesService(this.request);
+    this.primaryNetworkBlocks = new PrimaryNetworkBlocksService(this.request);
+    this.primaryNetworkRewards = new PrimaryNetworkRewardsService(this.request);
+    this.primaryNetworkTransactions = new PrimaryNetworkTransactionsService(this.request);
+    this.primaryNetworkUtxOs = new PrimaryNetworkUtxOsService(this.request);
+    this.primaryNetworkVertices = new PrimaryNetworkVerticesService(this.request);
+  }
+}
+
+const OpenAPI = {
+  BASE: "https://glacier-api-dev.avax.network",
+  VERSION: "Beta",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+exports.ActiveDelegatorDetails = void 0;
+((ActiveDelegatorDetails2) => {
+  ((delegationStatus2) => {
+    delegationStatus2["ACTIVE"] = "active";
+  })(ActiveDelegatorDetails2.delegationStatus || (ActiveDelegatorDetails2.delegationStatus = {}));
+})(exports.ActiveDelegatorDetails || (exports.ActiveDelegatorDetails = {}));
+
+exports.ActiveValidatorDetails = void 0;
+((ActiveValidatorDetails2) => {
+  ((validationStatus2) => {
+    validationStatus2["ACTIVE"] = "active";
+  })(ActiveValidatorDetails2.validationStatus || (ActiveValidatorDetails2.validationStatus = {}));
+})(exports.ActiveValidatorDetails || (exports.ActiveValidatorDetails = {}));
+
+var BlockchainId = /* @__PURE__ */ ((BlockchainId2) => {
+  BlockchainId2["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  BlockchainId2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  BlockchainId2["_2JVSBOINJ9C2J33VNTVZ_YT_VJNZD_N2NKIWW_KJCUM_HUWEB5DB_BRM"] = "2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm";
+  BlockchainId2["_2Q9E4R6MU3U68N_U1F_YJGB_R6JVWR_RX36COHP_AX5UQXSE55X1Q5"] = "2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5";
+  BlockchainId2["Y_H8D7TH_NJKXMTKUV2JG_BA4P1RN3QPR4P_PR7QYNFCDO_S6K6HWP"] = "yH8D7ThNJkxmtkuv2jgBa4P1Rn3Qpr4pPr7QYNfcdoS6k6HWp";
+  BlockchainId2["P_CHAIN"] = "p-chain";
+  BlockchainId2["X_CHAIN"] = "x-chain";
+  BlockchainId2["C_CHAIN"] = "c-chain";
+  return BlockchainId2;
+})(BlockchainId || {});
+
+var BlockchainIds = /* @__PURE__ */ ((BlockchainIds2) => {
+  BlockchainIds2["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  BlockchainIds2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  BlockchainIds2["_2JVSBOINJ9C2J33VNTVZ_YT_VJNZD_N2NKIWW_KJCUM_HUWEB5DB_BRM"] = "2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm";
+  BlockchainIds2["_2Q9E4R6MU3U68N_U1F_YJGB_R6JVWR_RX36COHP_AX5UQXSE55X1Q5"] = "2q9e4r6Mu3U68nU1fYjgbR6JvwrRx36CohpAX5UQxse55x1Q5";
+  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 || {});
+
+exports.CompletedDelegatorDetails = void 0;
+((CompletedDelegatorDetails2) => {
+  ((delegationStatus2) => {
+    delegationStatus2["COMPLETED"] = "completed";
+  })(CompletedDelegatorDetails2.delegationStatus || (CompletedDelegatorDetails2.delegationStatus = {}));
+})(exports.CompletedDelegatorDetails || (exports.CompletedDelegatorDetails = {}));
+
+exports.CompletedValidatorDetails = void 0;
+((CompletedValidatorDetails2) => {
+  ((validationStatus2) => {
+    validationStatus2["COMPLETED"] = "completed";
+  })(CompletedValidatorDetails2.validationStatus || (CompletedValidatorDetails2.validationStatus = {}));
+})(exports.CompletedValidatorDetails || (exports.CompletedValidatorDetails = {}));
+
+exports.ContractSubmissionErc1155 = void 0;
+((ContractSubmissionErc11552) => {
+  ((ercType2) => {
+    ercType2["ERC_1155"] = "ERC-1155";
+  })(ContractSubmissionErc11552.ercType || (ContractSubmissionErc11552.ercType = {}));
+})(exports.ContractSubmissionErc1155 || (exports.ContractSubmissionErc1155 = {}));
+
+exports.ContractSubmissionErc20 = void 0;
+((ContractSubmissionErc202) => {
+  ((ercType2) => {
+    ercType2["ERC_20"] = "ERC-20";
+  })(ContractSubmissionErc202.ercType || (ContractSubmissionErc202.ercType = {}));
+})(exports.ContractSubmissionErc20 || (exports.ContractSubmissionErc20 = {}));
+
+exports.ContractSubmissionErc721 = void 0;
+((ContractSubmissionErc7212) => {
+  ((ercType2) => {
+    ercType2["ERC_721"] = "ERC-721";
+  })(ContractSubmissionErc7212.ercType || (ContractSubmissionErc7212.ercType = {}));
+})(exports.ContractSubmissionErc721 || (exports.ContractSubmissionErc721 = {}));
+
+exports.ContractSubmissionUnknown = void 0;
+((ContractSubmissionUnknown2) => {
+  ((ercType2) => {
+    ercType2["UNKNOWN"] = "UNKNOWN";
+  })(ContractSubmissionUnknown2.ercType || (ContractSubmissionUnknown2.ercType = {}));
+})(exports.ContractSubmissionUnknown || (exports.ContractSubmissionUnknown = {}));
+
+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 || {});
+
+var DelegationStatusType = /* @__PURE__ */ ((DelegationStatusType2) => {
+  DelegationStatusType2["COMPLETED"] = "completed";
+  DelegationStatusType2["ACTIVE"] = "active";
+  DelegationStatusType2["PENDING"] = "pending";
+  return DelegationStatusType2;
+})(DelegationStatusType || {});
+
+exports.Erc1155Contract = void 0;
+((Erc1155Contract2) => {
+  ((ercType2) => {
+    ercType2["ERC_1155"] = "ERC-1155";
+  })(Erc1155Contract2.ercType || (Erc1155Contract2.ercType = {}));
+})(exports.Erc1155Contract || (exports.Erc1155Contract = {}));
+
+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.Erc20Contract = void 0;
+((Erc20Contract2) => {
+  ((ercType2) => {
+    ercType2["ERC_20"] = "ERC-20";
+  })(Erc20Contract2.ercType || (Erc20Contract2.ercType = {}));
+})(exports.Erc20Contract || (exports.Erc20Contract = {}));
+
+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.Erc721Contract = void 0;
+((Erc721Contract2) => {
+  ((ercType2) => {
+    ercType2["ERC_721"] = "ERC-721";
+  })(Erc721Contract2.ercType || (Erc721Contract2.ercType = {}));
+})(exports.Erc721Contract || (exports.Erc721Contract = {}));
+
+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 EventType = /* @__PURE__ */ ((EventType2) => {
+  EventType2["ADDRESS_ACTIVITY"] = "address_activity";
+  return EventType2;
+})(EventType || {});
+
+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 Network = /* @__PURE__ */ ((Network2) => {
+  Network2["MAINNET"] = "mainnet";
+  Network2["FUJI"] = "fuji";
+  return Network2;
+})(Network || {});
+
+var NetworkType = /* @__PURE__ */ ((NetworkType2) => {
+  NetworkType2["MAINNET"] = "mainnet";
+  NetworkType2["TESTNET"] = "testnet";
+  return NetworkType2;
+})(NetworkType || {});
+
+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["_11111111111111111111111111111111LPO_YY"] = "11111111111111111111111111111111LpoYY";
+  PChainId2["P_CHAIN"] = "p-chain";
+  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_PERMISSIONLESS_DELEGATOR_TX"] = "AddPermissionlessDelegatorTx";
+  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 || {});
+
+exports.PendingDelegatorDetails = void 0;
+((PendingDelegatorDetails2) => {
+  ((delegationStatus2) => {
+    delegationStatus2["PENDING"] = "pending";
+  })(PendingDelegatorDetails2.delegationStatus || (PendingDelegatorDetails2.delegationStatus = {}));
+})(exports.PendingDelegatorDetails || (exports.PendingDelegatorDetails = {}));
+
+exports.PendingValidatorDetails = void 0;
+((PendingValidatorDetails2) => {
+  ((validationStatus2) => {
+    validationStatus2["PENDING"] = "pending";
+  })(PendingValidatorDetails2.validationStatus || (PendingValidatorDetails2.validationStatus = {}));
+})(exports.PendingValidatorDetails || (exports.PendingValidatorDetails = {}));
+
+var PrimaryNetwork = /* @__PURE__ */ ((PrimaryNetwork2) => {
+  PrimaryNetwork2["MAINNET"] = "mainnet";
+  PrimaryNetwork2["FUJI"] = "fuji";
+  return PrimaryNetwork2;
+})(PrimaryNetwork || {});
+
+var PrimaryNetworkChainName = /* @__PURE__ */ ((PrimaryNetworkChainName2) => {
+  PrimaryNetworkChainName2["P_CHAIN"] = "p-chain";
+  PrimaryNetworkChainName2["X_CHAIN"] = "x-chain";
+  PrimaryNetworkChainName2["C_CHAIN"] = "c-chain";
+  return PrimaryNetworkChainName2;
+})(PrimaryNetworkChainName || {});
+
+var PrimaryNetworkTxType = /* @__PURE__ */ ((PrimaryNetworkTxType2) => {
+  PrimaryNetworkTxType2["ADD_VALIDATOR_TX"] = "AddValidatorTx";
+  PrimaryNetworkTxType2["ADD_DELEGATOR_TX"] = "AddDelegatorTx";
+  PrimaryNetworkTxType2["ADD_PERMISSIONLESS_VALIDATOR_TX"] = "AddPermissionlessValidatorTx";
+  PrimaryNetworkTxType2["ADD_PERMISSIONLESS_DELEGATOR_TX"] = "AddPermissionlessDelegatorTx";
+  PrimaryNetworkTxType2["ADD_SUBNET_VALIDATOR_TX"] = "AddSubnetValidatorTx";
+  PrimaryNetworkTxType2["REMOVE_SUBNET_VALIDATOR_TX"] = "RemoveSubnetValidatorTx";
+  PrimaryNetworkTxType2["REWARD_VALIDATOR_TX"] = "RewardValidatorTx";
+  PrimaryNetworkTxType2["CREATE_CHAIN_TX"] = "CreateChainTx";
+  PrimaryNetworkTxType2["CREATE_SUBNET_TX"] = "CreateSubnetTx";
+  PrimaryNetworkTxType2["IMPORT_TX"] = "ImportTx";
+  PrimaryNetworkTxType2["EXPORT_TX"] = "ExportTx";
+  PrimaryNetworkTxType2["ADVANCE_TIME_TX"] = "AdvanceTimeTx";
+  PrimaryNetworkTxType2["UNKNOWN"] = "UNKNOWN";
+  PrimaryNetworkTxType2["BASE_TX"] = "BaseTx";
+  PrimaryNetworkTxType2["CREATE_ASSET_TX"] = "CreateAssetTx";
+  PrimaryNetworkTxType2["OPERATION_TX"] = "OperationTx";
+  return PrimaryNetworkTxType2;
+})(PrimaryNetworkTxType || {});
+
+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";
+  RewardType2["VALIDATOR_FEE"] = "VALIDATOR_FEE";
+  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 || {});
+
+exports.UnknownContract = void 0;
+((UnknownContract2) => {
+  ((ercType2) => {
+    ercType2["UNKNOWN"] = "UNKNOWN";
+  })(UnknownContract2.ercType || (UnknownContract2.ercType = {}));
+})(exports.UnknownContract || (exports.UnknownContract = {}));
+
+var UtxoType = /* @__PURE__ */ ((UtxoType2) => {
+  UtxoType2["STAKE"] = "STAKE";
+  UtxoType2["TRANSFER"] = "TRANSFER";
+  return UtxoType2;
+})(UtxoType || {});
+
+var ValidationStatusType = /* @__PURE__ */ ((ValidationStatusType2) => {
+  ValidationStatusType2["COMPLETED"] = "completed";
+  ValidationStatusType2["ACTIVE"] = "active";
+  ValidationStatusType2["PENDING"] = "pending";
+  return ValidationStatusType2;
+})(ValidationStatusType || {});
+
+var VmName = /* @__PURE__ */ ((VmName2) => {
+  VmName2["EVM"] = "EVM";
+  VmName2["BITCOIN"] = "BITCOIN";
+  VmName2["ETHEREUM"] = "ETHEREUM";
+  return VmName2;
+})(VmName || {});
+
+var WebhookStatus = /* @__PURE__ */ ((WebhookStatus2) => {
+  WebhookStatus2["ACTIVE"] = "active";
+  WebhookStatus2["INACTIVE"] = "inactive";
+  return WebhookStatus2;
+})(WebhookStatus || {});
+
+var WebhookStatusType = /* @__PURE__ */ ((WebhookStatusType2) => {
+  WebhookStatusType2["ACTIVE"] = "active";
+  WebhookStatusType2["INACTIVE"] = "inactive";
+  return WebhookStatusType2;
+})(WebhookStatusType || {});
+
+var XChainId = /* @__PURE__ */ ((XChainId2) => {
+  XChainId2["_2O_YMBNV4E_NHYQK2FJJ_V5N_VQLDBTM_NJZQ5S3QS3LO6FTN_C6FBY_M"] = "2oYMBNV4eNHyqk2fjjV5nVQLDbtmNJzq5s3qs3Lo6ftnC6FByM";
+  XChainId2["_2JVSBOINJ9C2J33VNTVZ_YT_VJNZD_N2NKIWW_KJCUM_HUWEB5DB_BRM"] = "2JVSBoinj9C2J33VntvzYtVJNZdN2NKiwwKjcumHUWEb5DbBrm";
+  XChainId2["X_CHAIN"] = "x-chain";
+  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 = {}));
+
+var XChainTransactionType = /* @__PURE__ */ ((XChainTransactionType2) => {
+  XChainTransactionType2["BASE_TX"] = "BaseTx";
+  XChainTransactionType2["CREATE_ASSET_TX"] = "CreateAssetTx";
+  XChainTransactionType2["OPERATION_TX"] = "OperationTx";
+  XChainTransactionType2["IMPORT_TX"] = "ImportTx";
+  XChainTransactionType2["EXPORT_TX"] = "ExportTx";
+  XChainTransactionType2["UNKNOWN"] = "UNKNOWN";
+  return XChainTransactionType2;
+})(XChainTransactionType || {});
+
+exports.ApiError = ApiError;
+exports.BaseHttpRequest = BaseHttpRequest;
+exports.BlockchainId = BlockchainId;
+exports.BlockchainIds = BlockchainIds;
+exports.CancelError = CancelError;
+exports.CancelablePromise = CancelablePromise;
+exports.ChainStatus = ChainStatus;
+exports.CurrencyCode = CurrencyCode;
+exports.DefaultService = DefaultService;
+exports.DelegationStatusType = DelegationStatusType;
+exports.EventType = EventType;
+exports.EvmBalancesService = EvmBalancesService;
+exports.EvmBlocksService = EvmBlocksService;
+exports.EvmChainsService = EvmChainsService;
+exports.EvmContractsService = EvmContractsService;
+exports.EvmTransactionsService = EvmTransactionsService;
+exports.Glacier = Glacier;
+exports.HealthCheckService = HealthCheckService;
+exports.InternalTransactionOpCall = InternalTransactionOpCall;
+exports.Network = Network;
+exports.NetworkType = NetworkType;
+exports.NfTsService = NfTsService;
+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.PrimaryNetworkBalancesService = PrimaryNetworkBalancesService;
+exports.PrimaryNetworkBlocksService = PrimaryNetworkBlocksService;
+exports.PrimaryNetworkChainName = PrimaryNetworkChainName;
+exports.PrimaryNetworkRewardsService = PrimaryNetworkRewardsService;
+exports.PrimaryNetworkService = PrimaryNetworkService;
+exports.PrimaryNetworkTransactionsService = PrimaryNetworkTransactionsService;
+exports.PrimaryNetworkTxType = PrimaryNetworkTxType;
+exports.PrimaryNetworkUtxOsService = PrimaryNetworkUtxOsService;
+exports.PrimaryNetworkVerticesService = PrimaryNetworkVerticesService;
+exports.ResourceLinkType = ResourceLinkType;
+exports.RewardType = RewardType;
+exports.SortOrder = SortOrder;
+exports.TransactionMethodType = TransactionMethodType;
+exports.TransactionStatus = TransactionStatus;
+exports.UtxoType = UtxoType;
+exports.ValidationStatusType = ValidationStatusType;
+exports.VmName = VmName;
+exports.WebhookStatus = WebhookStatus;
+exports.WebhookStatusType = WebhookStatusType;
+exports.XChainId = XChainId;
+exports.XChainTransactionType = XChainTransactionType;