@lightsparkdev/core 1.0.9 → 1.0.11

package/dist/index.d.ts

@@ -1,5 +1,27 @@
 import { Observable } from 'zen-observable-ts';
-export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, b64decode, b64encode, bytesToHex, clamp, convertCurrencyAmount, convertCurrencyAmountValue, countryCodesToCurrencyCodes, createSha256Hash, defaultCurrencyCode, formatCurrencyStr, getCurrentLocale, getErrorMsg, hexToBytes, isBrowser, isCurrencyAmount, isCurrencyAmountObj, isCurrencyMap, isError, isErrorMsg, isErrorWithMessage, isNode, isNumber, isTest, isType, linearInterpolate, localeToCurrencyCode, localeToCurrencySymbol, mapCurrencyAmount, pollUntil, round, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.js';
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, b64decode, b64encode, bytesToHex, clamp, convertCurrencyAmount, convertCurrencyAmountValue, countryCodesToCurrencyCodes, createSha256Hash, defaultCurrencyCode, formatCurrencyStr, getCurrentLocale, getErrorMsg, hexToBytes, isBrowser, isCurrencyAmount, isCurrencyAmountObj, isCurrencyMap, isError, isErrorMsg, isErrorWithMessage, isNode, isNumber, isTest, isType, linearInterpolate, localeToCurrencyCode, localeToCurrencySymbol, mapCurrencyAmount, pollUntil, round, separateCurrencyStrParts, sleep, urlsafe_b64decode } from './utils/index.js';
+
+declare class LightsparkException extends Error {
+    code: string;
+    message: string;
+    extraInfo: Record<string, unknown> | undefined;
+    constructor(code: string, message: string, extraInfo?: Record<string, unknown>);
+}
+
+type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
+declare class Logger {
+    context: string;
+    loggingEnabled: boolean;
+    constructor(loggerContext: string, getLoggingEnabled?: GetLoggingEnabled);
+    updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled): Promise<void>;
+    info(message: string, ...rest: unknown[]): void;
+}
+
+declare enum ServerEnvironment {
+    PRODUCTION = "production",
+    DEV = "dev"
+}
+declare const apiDomainForEnvironment: (environment: ServerEnvironment) => string;
 
 type Headers = Record<string, string>;
 type WsConnectionParams = Record<string, unknown>;
@@ -9,13 +31,6 @@ interface AuthProvider {
     addWsConnectionParams(params: WsConnectionParams): Promise<WsConnectionParams>;
 }
 
-declare class LightsparkException extends Error {
-    code: string;
-    message: string;
-    extraInfo: Record<string, unknown> | undefined;
-    constructor(code: string, message: string, extraInfo?: Record<string, unknown>);
-}
-
 declare class LightsparkAuthException extends LightsparkException {
     constructor(message: string, extraInfo?: Record<string, unknown>);
 }
@@ -33,6 +48,20 @@ declare const ConfigKeys: {
 type ConfigKeys = (typeof ConfigKeys)[keyof typeof ConfigKeys];
 declare const getLocalStorageConfigItem: (key: ConfigKeys) => boolean;
 
+type OnlyKey = {
+    key: string;
+    alias?: never;
+};
+type OnlyAlias = {
+    key?: never;
+    alias: string;
+};
+type KeyOrAliasType = OnlyKey | OnlyAlias;
+declare const KeyOrAlias: {
+    key: (key: string) => OnlyKey;
+    alias: (alias: string) => OnlyAlias;
+};
+
 declare class LightsparkSigningException extends LightsparkException {
     constructor(message: string, extraInfo?: Record<string, unknown>);
 }
@@ -60,20 +89,6 @@ declare const DefaultCrypto: {
     importPrivateSigningKey: (keyData: Uint8Array) => Promise<CryptoKey | string>;
 };
 
-type OnlyKey = {
-    key: string;
-    alias?: never;
-};
-type OnlyAlias = {
-    key?: never;
-    alias: string;
-};
-type KeyOrAliasType = OnlyKey | OnlyAlias;
-declare const KeyOrAlias: {
-    key: (key: string) => OnlyKey;
-    alias: (alias: string) => OnlyAlias;
-};
-
 interface Alias {
     alias: string;
 }
@@ -109,15 +124,6 @@ declare class NodeKeyCache {
     private stripPemTags;
 }
 
-type GetLoggingEnabled = (() => Promise<boolean> | boolean) | undefined;
-declare class Logger {
-    context: string;
-    loggingEnabled: boolean;
-    constructor(loggerContext: string, getLoggingEnabled?: GetLoggingEnabled);
-    updateLoggingEnabled(getLoggingEnabled: GetLoggingEnabled): Promise<void>;
-    info(message: string, ...rest: unknown[]): void;
-}
-
 type Query<T> = {
     /** The string representation of the query payload for graphQL. **/
     queryPayload: string;
@@ -125,7 +131,10 @@ type Query<T> = {
     variables?: {
         [key: string]: unknown;
     };
-    /** The function that will be called to construct the object from the response. **/
+    /**
+     * The function that will be called to construct the object from the
+     * response. *
+     */
     constructObject: (rawData: any) => T;
     /** The id of the node that will be used to sign the query. **/
     signingNodeId?: string;
@@ -150,16 +159,10 @@ declare class Requester {
     }>;
     makeRawRequest(queryPayload: string, variables?: {
         [key: string]: unknown;
-    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any | null>;
+    }, signingNodeId?: string | undefined, skipAuth?: boolean): Promise<any>;
     private getSdkUserAgent;
     private stripProtocol;
     private addSigningDataIfNeeded;
 }
 
-declare enum ServerEnvironment {
-    PRODUCTION = "production",
-    DEV = "dev"
-}
-declare const apiDomainForEnvironment: (environment: ServerEnvironment) => string;
-
 export { AuthProvider, ConfigKeys, CryptoInterface, DefaultCrypto, GeneratedKeyPair, KeyOrAlias, KeyOrAliasType, LightsparkAuthException, LightsparkException, LightsparkSigningException, Logger, NodeKeyCache, Query, RSASigningKey, Requester, Secp256k1SigningKey, ServerEnvironment, SigningKey, SigningKeyType, StubAuthProvider, apiDomainForEnvironment, getLocalStorageConfigItem };

package/dist/index.js

@@ -35,7 +35,56 @@ import {
   separateCurrencyStrParts,
   sleep,
   urlsafe_b64decode
-} from "./chunk-UU6SHVGX.js";
+} from "./chunk-F3XHLUGC.js";
+
+// src/Logger.ts
+var Logger = class {
+  context;
+  loggingEnabled = false;
+  constructor(loggerContext, getLoggingEnabled) {
+    this.context = loggerContext;
+    void this.updateLoggingEnabled(getLoggingEnabled);
+  }
+  async updateLoggingEnabled(getLoggingEnabled) {
+    if (getLoggingEnabled) {
+      this.loggingEnabled = await getLoggingEnabled();
+    } else if (isTest) {
+      this.loggingEnabled = true;
+    } else if (isBrowser) {
+      try {
+        this.loggingEnabled = getLocalStorageConfigItem(
+          ConfigKeys.LoggingEnabled
+        );
+      } catch (e) {
+      }
+    }
+    if (this.loggingEnabled) {
+      console.log(`[${this.context}] Logging enabled`);
+    }
+  }
+  info(message, ...rest) {
+    if (this.loggingEnabled) {
+      console.log(`[${this.context}] ${message}`, ...rest);
+    }
+  }
+};
+var logger = new Logger("@lightsparkdev/core");
+
+// src/ServerEnvironment.ts
+var ServerEnvironment = /* @__PURE__ */ ((ServerEnvironment2) => {
+  ServerEnvironment2["PRODUCTION"] = "production";
+  ServerEnvironment2["DEV"] = "dev";
+  return ServerEnvironment2;
+})(ServerEnvironment || {});
+var apiDomainForEnvironment = (environment) => {
+  switch (environment) {
+    case "dev" /* DEV */:
+      return "api.dev.dev.sparkinfra.net";
+    case "production" /* PRODUCTION */:
+      return "api.lightspark.com";
+  }
+};
+var ServerEnvironment_default = ServerEnvironment;
 
 // src/auth/LightsparkAuthException.ts
 var LightsparkAuthException = class extends LightsparkException_default {
@@ -47,14 +96,14 @@ var LightsparkAuthException_default = LightsparkAuthException;
 
 // src/auth/StubAuthProvider.ts
 var StubAuthProvider = class {
-  async addAuthHeaders(headers) {
-    return headers;
+  addAuthHeaders(headers) {
+    return Promise.resolve(headers);
   }
-  async isAuthorized() {
-    return false;
+  isAuthorized() {
+    return Promise.resolve(false);
   }
-  async addWsConnectionParams(params) {
-    return params;
+  addWsConnectionParams(params) {
+    return Promise.resolve(params);
   }
 };
 
@@ -71,6 +120,12 @@ var getLocalStorageConfigItem = (key) => {
   }
 };
 
+// src/crypto/KeyOrAlias.ts
+var KeyOrAlias = {
+  key: (key) => ({ key }),
+  alias: (alias) => ({ alias })
+};
+
 // src/crypto/LightsparkSigningException.ts
 var LightsparkSigningException = class extends LightsparkException_default {
   constructor(message, extraInfo) {
@@ -79,6 +134,9 @@ var LightsparkSigningException = class extends LightsparkException_default {
 };
 var LightsparkSigningException_default = LightsparkSigningException;
 
+// src/crypto/NodeKeyCache.ts
+import autoBind from "auto-bind";
+
 // src/crypto/crypto.ts
 var getCrypto = () => {
   let cryptoImplPromise;
@@ -162,7 +220,7 @@ var decrypt = async (header_json, ciphertext, password) => {
   if (header.v < 0 || header.v > 4) {
     throw new LightsparkException_default(
       "DecryptionError",
-      "Unknown version ".concat(header.v)
+      `Unknown version ${header.v}`
     );
   }
   const cryptoImpl = await getCrypto();
@@ -173,7 +231,10 @@ var decrypt = async (header_json, ciphertext, password) => {
     const salt = decoded.slice(decoded.length - 8, decoded.length);
     const nonce = decoded.slice(0, 12);
     const cipherText = decoded.slice(12, decoded.length - 8);
-    const [key, _iv] = await deriveKey(
+    const [
+      key
+      /* , _iv */
+    ] = await deriveKey(
       password,
       salt,
       header.i,
@@ -283,15 +344,6 @@ var DefaultCrypto = {
   importPrivateSigningKey
 };
 
-// src/crypto/KeyOrAlias.ts
-var KeyOrAlias = {
-  key: (key) => ({ key }),
-  alias: (alias) => ({ alias })
-};
-
-// src/crypto/NodeKeyCache.ts
-import autoBind from "auto-bind";
-
 // src/crypto/SigningKey.ts
 import secp256k1 from "secp256k1";
 function isAlias(key) {
@@ -388,39 +440,6 @@ var NodeKeyCache = class {
 };
 var NodeKeyCache_default = NodeKeyCache;
 
-// src/Logger.ts
-var Logger = class {
-  context;
-  loggingEnabled = false;
-  constructor(loggerContext, getLoggingEnabled) {
-    this.context = loggerContext;
-    this.updateLoggingEnabled(getLoggingEnabled);
-  }
-  async updateLoggingEnabled(getLoggingEnabled) {
-    if (getLoggingEnabled) {
-      this.loggingEnabled = await getLoggingEnabled();
-    } else if (isTest) {
-      this.loggingEnabled = true;
-    } else if (isBrowser) {
-      try {
-        this.loggingEnabled = getLocalStorageConfigItem(
-          ConfigKeys.LoggingEnabled
-        );
-      } catch (e) {
-      }
-    }
-    if (this.loggingEnabled) {
-      console.log(`[${this.context}] Logging enabled`);
-    }
-  }
-  info(message, ...rest) {
-    if (this.loggingEnabled) {
-      console.log(`[${this.context}] ${message}`, ...rest);
-    }
-  }
-};
-var logger = new Logger("@lightsparkdev/core");
-
 // src/requester/Requester.ts
 import autoBind2 from "auto-bind";
 import dayjs from "dayjs";
@@ -545,6 +564,7 @@ var Requester = class {
     const url = `${urlWithProtocol}/${this.schemaEndpoint}`;
     logger.info(`Requester.makeRawRequest`, {
       url,
+      operationName: operation,
       variables
     });
     const response = await fetch(url, {
@@ -592,7 +612,7 @@ var Requester = class {
       nonce,
       expires_at: expiration
     };
-    const key = await this.nodeKeyCache.getKey(signingNodeId);
+    const key = this.nodeKeyCache.getKey(signingNodeId);
     if (!key) {
       throw new LightsparkSigningException_default(
         "Missing node of encrypted_signing_private_key"
@@ -615,22 +635,6 @@ var Requester = class {
   }
 };
 var Requester_default = Requester;
-
-// src/ServerEnvironment.ts
-var ServerEnvironment = /* @__PURE__ */ ((ServerEnvironment2) => {
-  ServerEnvironment2["PRODUCTION"] = "production";
-  ServerEnvironment2["DEV"] = "dev";
-  return ServerEnvironment2;
-})(ServerEnvironment || {});
-var apiDomainForEnvironment = (environment) => {
-  switch (environment) {
-    case "dev" /* DEV */:
-      return "api.dev.dev.sparkinfra.net";
-    case "production" /* PRODUCTION */:
-      return "api.lightspark.com";
-  }
-};
-var ServerEnvironment_default = ServerEnvironment;
 export {
   ConfigKeys,
   CurrencyUnit,

package/dist/utils/index.cjs

@@ -886,39 +886,38 @@ function sleep(ms) {
 function getDefaultMaxPollsError() {
   return new Error("pollUntil: Max polls reached");
 }
-function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
-  return new Promise((resolve, reject) => {
-    let polls = 0;
-    let stopPolling = false;
-    (async function() {
-      while (!stopPolling) {
-        polls += 1;
-        if (polls > maxPolls) {
-          stopPolling = true;
-          const maxPollsError = getMaxPollsError(maxPolls);
-          reject(maxPollsError);
-          break;
-        }
-        try {
-          const asyncResult = await asyncFn();
-          const result = getValue(asyncResult, {
-            stopPolling: false,
-            value: null
-          });
-          if (result.stopPolling) {
-            stopPolling = true;
-            resolve(result.value);
-          }
-        } catch (e) {
-          if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
-            stopPolling = true;
-            reject(e);
-          }
-        }
-        await sleep(pollIntervalMs);
+async function pollUntil(asyncFn, getValue, maxPolls = 60, pollIntervalMs = 500, ignoreErrors = false, getMaxPollsError = getDefaultMaxPollsError) {
+  let polls = 0;
+  let stopPolling = false;
+  let result = {
+    stopPolling: false,
+    value: null
+  };
+  while (!stopPolling) {
+    polls += 1;
+    if (polls > maxPolls) {
+      stopPolling = true;
+      const maxPollsError = getMaxPollsError(maxPolls);
+      throw maxPollsError;
+    }
+    try {
+      const asyncResult = await asyncFn();
+      result = getValue(asyncResult, {
+        stopPolling: false,
+        value: null
+      });
+      if (result.stopPolling) {
+        stopPolling = true;
       }
-    })();
-  });
+    } catch (e) {
+      if (!ignoreErrors || isFunction_default(ignoreErrors) && !ignoreErrors(e)) {
+        stopPolling = true;
+        throw e;
+      }
+    }
+    await sleep(pollIntervalMs);
+  }
+  return result.value;
 }
 
 // src/utils/types.ts

package/dist/utils/index.d.cts

@@ -0,0 +1,252 @@
+declare const b64decode: (encoded: string) => Uint8Array;
+declare const urlsafe_b64decode: (encoded: string) => Uint8Array;
+declare const b64encode: (data: ArrayBuffer) => string;
+
+type SourceData = Uint8Array | string;
+declare function createSha256Hash(data: SourceData): Promise<Uint8Array>;
+declare function createSha256Hash(data: SourceData, asHex: true): Promise<string>;
+
+declare const defaultCurrencyCode = "USD";
+/**
+ * This enum identifies the unit of currency associated with a CurrencyAmount.
+ * *
+ */
+declare enum CurrencyUnit {
+    /**
+     * This is an enum value that represents values that could be added in the
+     * future. Clients should support unknown values as more of them could be
+     * added without notice.
+     */
+    FUTURE_VALUE = "FUTURE_VALUE",
+    /**
+     * Bitcoin is the cryptocurrency native to the Bitcoin network.
+     * It is used as the native medium for value transfer for the Lightning
+     * Network. *
+     */
+    BITCOIN = "BITCOIN",
+    /**
+     * 0.00000001 (10e-8) Bitcoin or one hundred millionth of a Bitcoin.
+     * This is the unit most commonly used in Lightning transactions.
+     * *
+     */
+    SATOSHI = "SATOSHI",
+    /**
+     * 0.001 Satoshi, or 10e-11 Bitcoin. We recommend using the Satoshi unit
+     * instead when possible. *
+     */
+    MILLISATOSHI = "MILLISATOSHI",
+    /** United States Dollar. **/
+    USD = "USD",
+    /**
+     * 0.000000001 (10e-9) Bitcoin or a billionth of a Bitcoin.
+     * We recommend using the Satoshi unit instead when possible.
+     * *
+     */
+    NANOBITCOIN = "NANOBITCOIN",
+    /**
+     * 0.000001 (10e-6) Bitcoin or a millionth of a Bitcoin.
+     * We recommend using the Satoshi unit instead when possible.
+     * *
+     */
+    MICROBITCOIN = "MICROBITCOIN",
+    /**
+     * 0.001 (10e-3) Bitcoin or a thousandth of a Bitcoin.
+     * We recommend using the Satoshi unit instead when possible.
+     * *
+     */
+    MILLIBITCOIN = "MILLIBITCOIN"
+}
+/** This object represents the value and unit for an amount of currency. **/
+type CurrencyAmountType = {
+    /** The original numeric value for this CurrencyAmount. **/
+    originalValue: number;
+    /** The original unit of currency for this CurrencyAmount. **/
+    originalUnit: CurrencyUnit;
+    /** The unit of user's preferred currency. **/
+    preferredCurrencyUnit: CurrencyUnit;
+    /**
+     * The rounded numeric value for this CurrencyAmount in the very base level
+     * of user's preferred currency. For example, for USD, the value will be in
+     * cents.
+     **/
+    preferredCurrencyValueRounded: number;
+    /**
+     * The approximate float value for this CurrencyAmount in the very base level
+     * of user's preferred currency. For example, for USD, the value will be in
+     * cents.
+     **/
+    preferredCurrencyValueApprox: number;
+};
+declare function convertCurrencyAmountValue(fromUnit: CurrencyUnit, toUnit: CurrencyUnit, amount: number, centsPerBtc?: number): number;
+declare const convertCurrencyAmount: (from: CurrencyAmountType, toUnit: CurrencyUnit) => CurrencyAmountType;
+type CurrencyMap = {
+    sats: number;
+    msats: number;
+    btc: number;
+    [CurrencyUnit.BITCOIN]: number;
+    [CurrencyUnit.SATOSHI]: number;
+    [CurrencyUnit.MILLISATOSHI]: number;
+    [CurrencyUnit.MICROBITCOIN]: number;
+    [CurrencyUnit.MILLIBITCOIN]: number;
+    [CurrencyUnit.NANOBITCOIN]: number;
+    [CurrencyUnit.USD]: number;
+    [CurrencyUnit.FUTURE_VALUE]: number;
+    formatted: {
+        sats: string;
+        msats: string;
+        btc: string;
+        [CurrencyUnit.BITCOIN]: string;
+        [CurrencyUnit.SATOSHI]: string;
+        [CurrencyUnit.MILLISATOSHI]: string;
+        [CurrencyUnit.MILLIBITCOIN]: string;
+        [CurrencyUnit.MICROBITCOIN]: string;
+        [CurrencyUnit.NANOBITCOIN]: string;
+        [CurrencyUnit.USD]: string;
+        [CurrencyUnit.FUTURE_VALUE]: string;
+    };
+    isZero: boolean;
+    isLessThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isGreaterThan: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    isEqualTo: (other: CurrencyMap | CurrencyAmountObj | number) => boolean;
+    type: "CurrencyMap";
+};
+type CurrencyAmountObj = {
+    value?: number | string | null;
+    unit?: CurrencyUnit;
+    __typename?: "CurrencyAmount";
+};
+type CurrencyAmountArg = CurrencyAmountObj | CurrencyAmountType | undefined | null;
+declare function isCurrencyAmountObj(arg: unknown): arg is CurrencyAmountObj;
+declare function isCurrencyAmount(arg: unknown): arg is CurrencyAmountType;
+declare function mapCurrencyAmount(currencyAmountArg: CurrencyAmountArg, centsPerBtc?: number): CurrencyMap;
+declare const isCurrencyMap: (currencyMap: unknown) => currencyMap is CurrencyMap;
+declare const abbrCurrencyUnit: (unit: CurrencyUnit) => "USD" | "BTC" | "SAT" | "MSAT" | "Unsupported CurrencyUnit";
+declare function formatCurrencyStr(amount: CurrencyAmountArg, maxFractionDigits?: number, compact?: boolean, showBtcSymbol?: boolean, options?: Intl.NumberFormatOptions): string;
+declare function separateCurrencyStrParts(currencyStr: string): {
+    symbol: string;
+    amount: string;
+};
+declare function localeToCurrencySymbol(locale: string): string;
+
+declare const isBrowser: boolean;
+declare const isNode: boolean;
+declare const isTest: boolean;
+
+declare const isError: (e: unknown) => e is Error;
+type ErrorWithMessage = {
+    message: string;
+};
+declare const isErrorWithMessage: (e: unknown) => e is ErrorWithMessage;
+declare const getErrorMsg: (e: unknown) => string;
+declare const isErrorMsg: (e: unknown, msg: string) => boolean;
+
+declare const bytesToHex: (bytes: Uint8Array) => string;
+declare const hexToBytes: (hex: string) => Uint8Array;
+
+declare function getCurrentLocale(): string;
+
+declare const countryCodesToCurrencyCodes: {
+    readonly AD: "EUR";
+    readonly AR: "ARS";
+    readonly AS: "USD";
+    readonly AT: "EUR";
+    readonly AU: "AUD";
+    readonly AX: "EUR";
+    readonly BE: "EUR";
+    readonly BL: "EUR";
+    readonly BQ: "USD";
+    readonly BR: "BRL";
+    readonly CA: "CAD";
+    readonly CO: "COP";
+    readonly CY: "EUR";
+    readonly DE: "EUR";
+    readonly EC: "USD";
+    readonly EE: "EUR";
+    readonly ES: "EUR";
+    readonly FI: "EUR";
+    readonly FM: "USD";
+    readonly FR: "EUR";
+    readonly GB: "GBP";
+    readonly GF: "EUR";
+    readonly GG: "GBP";
+    readonly GP: "EUR";
+    readonly GR: "EUR";
+    readonly GS: "GBP";
+    readonly GU: "USD";
+    readonly IE: "EUR";
+    readonly IM: "GBP";
+    readonly IN: "INR";
+    readonly IO: "USD";
+    readonly IT: "EUR";
+    readonly JE: "GBP";
+    readonly LT: "EUR";
+    readonly LU: "EUR";
+    readonly LV: "EUR";
+    readonly MC: "EUR";
+    readonly ME: "EUR";
+    readonly MF: "EUR";
+    readonly MH: "USD";
+    readonly MP: "USD";
+    readonly MQ: "EUR";
+    readonly MT: "EUR";
+    readonly MX: "MXN";
+    readonly NF: "AUD";
+    readonly NL: "EUR";
+    readonly NR: "AUD";
+    readonly PM: "EUR";
+    readonly PR: "USD";
+    readonly PT: "EUR";
+    readonly PW: "USD";
+    readonly RE: "EUR";
+    readonly SI: "EUR";
+    readonly SK: "EUR";
+    readonly SM: "EUR";
+    readonly TC: "USD";
+    readonly TF: "EUR";
+    readonly TL: "USD";
+    readonly TV: "AUD";
+    readonly UM: "USD";
+    readonly US: "USD";
+    readonly VA: "EUR";
+    readonly VG: "USD";
+    readonly VI: "USD";
+    readonly YT: "EUR";
+};
+type CurrencyLocales = keyof typeof countryCodesToCurrencyCodes;
+type CurrencyCodes = (typeof countryCodesToCurrencyCodes)[CurrencyLocales];
+declare function localeToCurrencyCode(locale: string): CurrencyCodes;
+
+declare function clamp(val: number, min: number, max: number): number;
+declare function linearInterpolate(value: number, fromRangeStart: number, fromRangeEnd: number, toRangeStart: number, toRangeEnd: number): number;
+declare function round(num: number, decimalPlaces?: number): number;
+declare function isNumber(value: unknown): value is number;
+
+type GetValueResult<T> = {
+    stopPolling: boolean;
+    value: null | T;
+};
+declare function pollUntil<D extends () => Promise<unknown>, T>(asyncFn: D, getValue: (data: Awaited<ReturnType<D>>, response: {
+    stopPolling: boolean;
+    value: null | T;
+}) => GetValueResult<T>, maxPolls?: number, pollIntervalMs?: number, ignoreErrors?: boolean | ((e: unknown) => boolean), getMaxPollsError?: (maxPolls: number) => Error): Promise<T>;
+
+declare function sleep(ms: number): Promise<unknown>;
+
+type Maybe<T> = T | null | undefined;
+type ExpandRecursively<T> = T extends object ? T extends infer O ? {
+    [K in keyof O]: ExpandRecursively<O[K]>;
+} : never : T;
+type ById<T> = {
+    [id: string]: T;
+};
+type OmitTypename<T> = Omit<T, "__typename">;
+declare const isType: <T extends string>(typename: T) => <N extends {
+    __typename: string;
+}>(node: N | null | undefined) => node is Extract<N, {
+    __typename: T;
+}>;
+type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+
+export { ById, CurrencyAmountArg, CurrencyAmountObj, CurrencyAmountType, CurrencyCodes, CurrencyLocales, CurrencyMap, CurrencyUnit, DeepPartial, ExpandRecursively, Maybe, OmitTypename, abbrCurrencyUnit, b64decode, b64encode, bytesToHex, clamp, convertCurrencyAmount, convertCurrencyAmountValue, countryCodesToCurrencyCodes, createSha256Hash, defaultCurrencyCode, formatCurrencyStr, getCurrentLocale, getErrorMsg, hexToBytes, isBrowser, isCurrencyAmount, isCurrencyAmountObj, isCurrencyMap, isError, isErrorMsg, isErrorWithMessage, isNode, isNumber, isTest, isType, linearInterpolate, localeToCurrencyCode, localeToCurrencySymbol, mapCurrencyAmount, pollUntil, round, separateCurrencyStrParts, sleep, urlsafe_b64decode };