@webority/mobile-core 0.0.23

package/lib/module/validators/index.js

@@ -0,0 +1,205 @@
+"use strict";
+
+/**
+ * Generic validators returning `boolean`. All accept `null`/`undefined` safely.
+ *
+ * Tradeoff: regexes are pragmatic, not RFC-strict. They reject the things real users
+ * typo and accept the long tail of legitimate inputs. For RFC-grade validation use
+ * a dedicated library at the boundary.
+ */
+
+const RE_EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const RE_INDIAN_MOBILE = /^[6-9]\d{9}$/;
+const RE_NUMERIC = /^-?\d+(?:\.\d+)?$/;
+const RE_INTEGER = /^-?\d+$/;
+const RE_ALPHANUMERIC = /^[a-zA-Z0-9]+$/;
+const RE_PINCODE_IN = /^[1-9]\d{5}$/;
+const RE_PAN = /^[A-Z]{5}\d{4}[A-Z]$/;
+const RE_GSTIN = /^\d{2}[A-Z]{5}\d{4}[A-Z][1-9A-Z]Z[0-9A-Z]$/;
+// UIDAI issues no Aadhaar number starting 0 or 1.
+const RE_AADHAAR = /^[2-9]\d{11}$/;
+const RE_IFSC = /^[A-Z]{4}0[A-Z0-9]{6}$/;
+const RE_HEX_COLOR = /^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/;
+const asString = v => {
+  if (typeof v === 'string') {
+    return v.trim();
+  }
+  return null;
+};
+export const isNonEmpty = value => {
+  const s = asString(value);
+  return !!s && s.length > 0;
+};
+export const isEmail = value => {
+  const s = asString(value);
+  return !!s && RE_EMAIL.test(s);
+};
+
+/**
+ * Validate an Indian mobile number. Accepts:
+ * - 10-digit number starting with 6-9
+ * - Optional `+91` or `91` country code prefix
+ */
+export const isIndianMobile = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/\D/g, '');
+  const tail = digits.startsWith('91') && digits.length === 12 ? digits.slice(2) : digits;
+  return RE_INDIAN_MOBILE.test(tail);
+};
+
+/**
+ * Generic phone validator: 7–15 digits, optional `+` prefix.
+ * Use `isIndianMobile` when you specifically need an Indian mobile number.
+ */
+export const isPhone = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/[^\d+]/g, '').replace(/^\+/, '');
+  return digits.length >= 7 && digits.length <= 15 && /^\d+$/.test(digits);
+};
+export const isUrl = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  try {
+    // URL constructor is available on Hermes & JSC.
+
+    new URL(s);
+    return /^https?:\/\//i.test(s) || /^[a-z][a-z0-9+\-.]*:\/\//i.test(s);
+  } catch {
+    return false;
+  }
+};
+export const isNumeric = value => {
+  if (typeof value === 'number') {
+    return Number.isFinite(value);
+  }
+  const s = asString(value);
+  return !!s && RE_NUMERIC.test(s);
+};
+export const isInteger = value => {
+  if (typeof value === 'number') {
+    return Number.isInteger(value);
+  }
+  const s = asString(value);
+  return !!s && RE_INTEGER.test(s);
+};
+export const isAlphanumeric = value => {
+  const s = asString(value);
+  return !!s && RE_ALPHANUMERIC.test(s);
+};
+/**
+ * Common password complexity check. Defaults to 8+ chars,
+ * one uppercase, one lowercase, one digit.
+ */
+export const isStrongPassword = (value, rules = {}) => {
+  if (typeof value !== 'string') {
+    return false;
+  }
+  const {
+    minLength = 8,
+    requireUppercase = true,
+    requireLowercase = true,
+    requireNumber = true,
+    requireSymbol = false
+  } = rules;
+  if (value.length < minLength) {
+    return false;
+  }
+  if (requireUppercase && !/[A-Z]/.test(value)) {
+    return false;
+  }
+  if (requireLowercase && !/[a-z]/.test(value)) {
+    return false;
+  }
+  if (requireNumber && !/\d/.test(value)) {
+    return false;
+  }
+  if (requireSymbol && !/[^A-Za-z0-9]/.test(value)) {
+    return false;
+  }
+  return true;
+};
+export const isIndianPincode = value => {
+  const s = asString(value);
+  return !!s && RE_PINCODE_IN.test(s);
+};
+export const isPan = value => {
+  const s = asString(value);
+  return !!s && RE_PAN.test(s.toUpperCase());
+};
+const BASE_36 = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+
+/**
+ * The GSTN check character: each of the first fourteen characters' base-36
+ * value times a weight alternating 1 and 2, the product's quotient and
+ * remainder by 36 summed; the check character makes the total a multiple of 36.
+ */
+const gstinCheckCharacter = gstin => {
+  let sum = 0;
+  for (let i = 0; i < 14; i += 1) {
+    const product = BASE_36.indexOf(gstin[i]) * (i % 2 === 0 ? 1 : 2);
+    sum += Math.floor(product / 36) + product % 36;
+  }
+  return BASE_36[(36 - sum % 36) % 36];
+};
+export const isGstin = value => {
+  const s = asString(value)?.toUpperCase();
+  return !!s && RE_GSTIN.test(s) && s[14] === gstinCheckCharacter(s);
+};
+const VERHOEFF_D = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 2, 3, 4, 0, 6, 7, 8, 9, 5], [2, 3, 4, 0, 1, 7, 8, 9, 5, 6], [3, 4, 0, 1, 2, 8, 9, 5, 6, 7], [4, 0, 1, 2, 3, 9, 5, 6, 7, 8], [5, 9, 8, 7, 6, 0, 4, 3, 2, 1], [6, 5, 9, 8, 7, 1, 0, 4, 3, 2], [7, 6, 5, 9, 8, 2, 1, 0, 4, 3], [8, 7, 6, 5, 9, 3, 2, 1, 0, 4], [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]];
+const VERHOEFF_P = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [1, 5, 7, 6, 2, 8, 3, 0, 9, 4], [5, 8, 0, 3, 7, 9, 6, 1, 4, 2], [8, 9, 1, 6, 0, 4, 3, 5, 2, 7], [9, 4, 5, 3, 1, 2, 6, 8, 7, 0], [4, 2, 8, 6, 5, 7, 3, 9, 0, 1], [2, 7, 9, 3, 8, 0, 6, 4, 1, 5], [7, 0, 4, 6, 9, 1, 3, 2, 5, 8]];
+
+/** Verhoeff (dihedral group D5): valid when the running product over the reversed digits is 0. */
+const isVerhoeffValid = digits => {
+  let check = 0;
+  for (let i = 0; i < digits.length; i += 1) {
+    const digit = Number(digits[digits.length - 1 - i]);
+    check = VERHOEFF_D[check][VERHOEFF_P[i % 8][digit]];
+  }
+  return check === 0;
+};
+
+/**
+ * The same rules the Webority servers apply: spaces and hyphens stripped (as
+ * printed on the card), twelve digits, no leading 0 or 1, and a correct
+ * Verhoeff check digit.
+ */
+export const isAadhaar = value => {
+  const s = asString(value);
+  if (!s) {
+    return false;
+  }
+  const digits = s.replace(/[\s-]/g, '');
+  return RE_AADHAAR.test(digits) && isVerhoeffValid(digits);
+};
+export const isIfsc = value => {
+  const s = asString(value);
+  return !!s && RE_IFSC.test(s.toUpperCase());
+};
+export const isHexColor = value => {
+  const s = asString(value);
+  return !!s && RE_HEX_COLOR.test(s);
+};
+export const isBetween = (value, min, max, inclusive = true) => {
+  const n = typeof value === 'number' ? value : Number(asString(value));
+  if (!Number.isFinite(n)) {
+    return false;
+  }
+  return inclusive ? n >= min && n <= max : n > min && n < max;
+};
+export const minLength = (value, length) => {
+  const s = asString(value);
+  return !!s && s.length >= length;
+};
+export const maxLength = (value, length) => {
+  const s = asString(value);
+  return s == null ? true : s.length <= length;
+};
+//# sourceMappingURL=index.js.map

package/lib/module/versionCheck/index.js

@@ -0,0 +1,413 @@
+"use strict";
+
+import * as Application from 'expo-application';
+import { useEffect, useState } from 'react';
+// Type-only — erased at compile time; react-native stays lazily required below.
+
+import { getConfigValue } from "../config/index.js";
+import { Logger } from "../logger/index.js";
+
+/**
+ * Minimal device-info shape we depend on.
+ *
+ * This is a LAST RESORT, not the primary path. `Platform.OS` already gives the
+ * platform, and every Webority app carries its own store id and version in
+ * `appsettings.Compiled.json` — so `setConfig({ appId, appVersion })` covers
+ * both remaining values without a native module. The injector below exists for
+ * apps that would rather hand us a `react-native-device-info` instance than
+ * wire two config keys.
+ */
+
+/**
+ * expo-application, read at call time.
+ *
+ * `applicationId` and `nativeApplicationVersion` are module CONSTANTS rather
+ * than functions, so they are read inside the accessors rather than captured
+ * here — capturing would snapshot them before the native module has
+ * initialised.
+ *
+ * `setConfig({ appId, appVersion })` still WINS over this: a Webority app
+ * already carries both in appsettings.Compiled.json, and config is checked
+ * first. This is the fallback for an app that would rather read its identity
+ * from the binary it is actually running, which is the one place the two can
+ * disagree.
+ */
+const expoApplicationBackend = {
+  getBundleId: () => Application.applicationId ?? '',
+  getVersion: () => Application.nativeApplicationVersion ?? ''
+};
+
+/** Only what a test or the showcase injected; null means use expo-application. */
+let deviceInfo = null;
+
+/**
+ * Supply the app identity from a native module instead of config.
+ * Prefer `setConfig({ appId, appVersion })` — it needs no native dependency.
+ * Pass `null` to clear.
+ */
+export const setDeviceInfoImplementation = impl => {
+  deviceInfo = impl;
+};
+const missing = (what, configKey) => {
+  const err = new Error(`[VersionCheck] the app's ${what} is not available. Call ` + `setConfig({ ${configKey}: '...' }) — every Webority app already has this value in ` + 'appsettings.Compiled.json — or setDeviceInfoImplementation() with a native provider.');
+  Logger.error(err.message);
+  return err;
+};
+
+// Platform comes from React Native itself; there has never been a reason to
+// cross a native module boundary for it.
+const getSystemName = () => {
+  const {
+    Platform
+  } = require('react-native');
+  return Platform.OS;
+};
+const getBundleId = () => {
+  const fromConfig = getConfigValue('appId');
+  if (fromConfig) {
+    return fromConfig;
+  }
+  const fromDevice = (deviceInfo ?? expoApplicationBackend).getBundleId();
+  if (fromDevice) {
+    return fromDevice;
+  }
+  throw missing('store identifier', 'appId');
+};
+const getVersion = () => {
+  const fromConfig = getConfigValue('appVersion');
+  if (fromConfig) {
+    return fromConfig;
+  }
+  const fromDevice = (deviceInfo ?? expoApplicationBackend).getVersion();
+  if (fromDevice) {
+    return fromDevice;
+  }
+  throw missing('version', 'appVersion');
+};
+
+// Constants
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 3000; // 3 seconds
+
+const getCountry = () => getConfigValue('country', 'in').toLowerCase();
+// Utility function to parse and coerce version to a valid format
+const parseVersion = version => {
+  Logger.info(`Parsing version: ${version}`);
+  const coercedVersion = version.replace(/[^0-9.]/g, '');
+  const versionParts = coercedVersion.split('.').map(Number);
+  return {
+    major: versionParts[0] || 0,
+    minor: versionParts[1] || 0,
+    patch: versionParts[2] || 0,
+    prerelease: version.includes('-') ? version.split('-')[1] ?? '' : ''
+  };
+};
+
+// Utility function to compare two versions loosely
+const diffLoose = (version1, version2) => {
+  Logger.info(`Comparing versions: ${version1} and ${version2}`);
+  if (version1 === version2) {
+    return null;
+  }
+  const v1 = parseVersion(version1);
+  const v2 = parseVersion(version2);
+  if (v1.major < v2.major) {
+    return 'major';
+  }
+  if (v1.major > v2.major) {
+    return null;
+  }
+  if (v1.minor < v2.minor) {
+    return 'minor';
+  }
+  if (v1.minor > v2.minor) {
+    return null;
+  }
+  if (v1.patch < v2.patch) {
+    return 'patch';
+  }
+  if (v1.patch > v2.patch) {
+    return null;
+  }
+  if (v1.prerelease && !v2.prerelease) {
+    return 'prerelease';
+  }
+  if (!v1.prerelease && v2.prerelease) {
+    return null;
+  }
+  if (v1.prerelease < v2.prerelease) {
+    return 'prerelease';
+  }
+  if (v1.prerelease > v2.prerelease) {
+    return null;
+  }
+  return null;
+};
+
+// Function to compare current version with the latest version
+const versionCompare = (currentVersion, latestVersion) => {
+  Logger.info(`Comparing current version: ${currentVersion} with latest version: ${latestVersion}`);
+  if (!latestVersion) {
+    return {
+      needsUpdate: false,
+      updateType: null,
+      notice: 'Error: could not get latest version'
+    };
+  }
+  try {
+    const updateType = diffLoose(currentVersion, latestVersion);
+    return {
+      needsUpdate: !!updateType,
+      updateType
+    };
+  } catch (e) {
+    const message = e instanceof Error ? e.message : String(e);
+    Logger.error(`Error comparing versions: ${message}`);
+    const needsUpdate = currentVersion !== latestVersion && latestVersion > currentVersion;
+    const updateType = needsUpdate ? 'minor' : null;
+    return {
+      needsUpdate,
+      updateType,
+      notice: message.replace(/^Invalid Version:/, 'Not a valid version:')
+    };
+  }
+};
+
+// Function to fetch version details from Google Play Store
+const fetchAndroidVersion = async url => {
+  Logger.info(`Fetching Android version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0.1; Nexus 5X Build/MMB29P) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.96 Mobile Safari/537.36',
+        'sec-fetch-site': 'same-origin'
+      }
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    Logger.error(`Error fetching data from Google Play Store: ${message}`);
+    throw new Error('Error fetching data from Google Play Store.');
+  }
+  if (!response.ok) {
+    if (response.status === 404) {
+      Logger.error('App with app ID not found in Google Play.');
+      throw new Error(`App with app ID not found in Google Play.`);
+    }
+    Logger.error(`Error fetching data: ${response.statusText}`);
+    throw new Error(response.statusText);
+  }
+  const text = await response.text();
+
+  // Primary regex pattern for current Play Store format
+  let versionMatch = text.match(/\[\[\[['"]((\d+\.)+\d+)['"]\]\],/);
+
+  // Alternate patterns as fallbacks
+  if (!versionMatch) {
+    // Fallback 1: Look for version in "current version" text
+    versionMatch = text.match(/Current Version[^\d]+((\d+\.)+\d+)/i);
+  }
+  if (!versionMatch) {
+    // Fallback 2: Look for itemprop="softwareVersion"
+    versionMatch = text.match(/itemprop="softwareVersion"[^>]*>((\d+\.)+\d+)</i);
+  }
+  if (!versionMatch) {
+    // Fallback 3: Try a more generic pattern for version numbers
+    const allVersions = text.match(/(\d+\.\d+(\.\d+)?)/g);
+    // If we found multiple version-like strings, use the first one
+    versionMatch = allVersions && allVersions.length > 0 ? [null, allVersions[0]] : null;
+  }
+  const version = versionMatch ? versionMatch[1] ?? null : null;
+  if (!version) {
+    Logger.warn('Could not extract version from Play Store. Using fallback method.');
+  }
+  const notesMatch = text.match(/<div itemprop="description">(.*?)<\/div>/);
+  const notes = notesMatch ? notesMatch[1] ?? '' : '';
+  return {
+    version,
+    releasedAt: new Date().toISOString(),
+    notes,
+    url,
+    lastChecked: new Date().toISOString()
+  };
+};
+// Function to fetch version details from Apple App Store
+const fetchIosVersion = async url => {
+  Logger.info(`Fetching iOS version from URL: ${url}`);
+  let response;
+  try {
+    response = await fetch(url);
+  } catch {
+    Logger.error('Error connecting to iTunes.');
+    throw new Error('Error connecting to iTunes.');
+  }
+  const data = await response.json();
+  if (!data || !('results' in data)) {
+    Logger.error('Unknown error connecting to iTunes.');
+    throw new Error('Unknown error connecting to iTunes.');
+  }
+  if (!data.results.length) {
+    Logger.error('App for this bundle ID not found.');
+    throw new Error('App for this bundle ID not found.');
+  }
+  const result = data.results[0];
+  return {
+    version: result.version || null,
+    released: result.currentVersionReleaseDate || result.releaseDate || null,
+    notes: result.releaseNotes || '',
+    url: result.trackViewUrl || result.artistViewUrl || result.sellerUrl || null,
+    country: getCountry(),
+    lastChecked: new Date().toISOString()
+  };
+};
+
+// Function to lookup version based on platform
+const lookupVersion = async (platform, identifier) => {
+  Logger.info(`Looking up version for platform: ${platform}, identifier: ${identifier}`);
+  const country = getCountry();
+  const url = platform === 'ios' ? `https://itunes.apple.com/lookup?bundleId=${identifier}&country=${country}&_=${new Date().valueOf()}` : `https://play.google.com/store/apps/details?id=${identifier}&hl=${country}`;
+  return platform === 'ios' ? fetchIosVersion(url) : fetchAndroidVersion(url);
+};
+
+/**
+ * Check for new version with retry logic
+ */
+const checkForUpdates = async () => {
+  const platform = getSystemName().toLowerCase();
+  const identifier = getBundleId();
+  const currentVersion = getVersion();
+
+  // Implement retry mechanism
+  let retryCount = 0;
+  let lastError = null;
+  while (retryCount <= MAX_RETRIES) {
+    try {
+      Logger.info(`Checking if new version is available (attempt ${retryCount + 1}/${MAX_RETRIES + 1})`);
+      Logger.info(`Platform: ${platform}, identifier: ${identifier}, current version: ${currentVersion}`);
+      const latestVersionInfo = await lookupVersion(platform, identifier);
+      const comparison = versionCompare(currentVersion, latestVersionInfo.version);
+      return {
+        isNewVersionAvailable: comparison.needsUpdate,
+        updateType: comparison.updateType,
+        url: latestVersionInfo.url
+      };
+    } catch (error) {
+      lastError = error;
+      const message = error instanceof Error ? error.message : String(error);
+      Logger.error(`Error checking version (attempt ${retryCount + 1}/${MAX_RETRIES + 1}): ${message}`);
+
+      // If we've reached max retries, throw the last error
+      if (retryCount === MAX_RETRIES) {
+        throw error;
+      }
+
+      // Otherwise, wait and retry
+      retryCount++;
+      Logger.info(`Retrying version check in ${RETRY_DELAY}ms...`);
+      await new Promise(resolve => setTimeout(resolve, RETRY_DELAY));
+    }
+  }
+
+  // This should never be reached due to the throw above, but just in case
+  throw lastError instanceof Error ? lastError : new Error('Failed to check for updates after multiple attempts');
+};
+
+/**
+ * Get fallback store URL based on platform
+ */
+const getFallbackStoreUrl = () => {
+  const platform = getSystemName().toLowerCase();
+  const bundleId = getBundleId();
+  const country = getCountry();
+  return platform === 'ios' ? `https://apps.apple.com/${country}/app/${bundleId}` : `https://play.google.com/store/apps/details?id=${bundleId}&hl=${country}`;
+};
+// Version check functionality
+export const VersionCheck = {
+  isNewVersionAvailable: async () => {
+    return checkForUpdates();
+  },
+  openUpdateUrl: async url => {
+    const {
+      Linking
+    } = require('react-native');
+    try {
+      if (url) {
+        Logger.info(`Opening app store URL: ${url}`);
+        await Linking.openURL(url);
+      } else {
+        const fallbackUrl = getFallbackStoreUrl();
+        Logger.info(`Opening fallback store URL: ${fallbackUrl}`);
+        await Linking.openURL(fallbackUrl);
+      }
+      return true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      Logger.error(`Failed to open store URL: ${message}`);
+
+      // Try with fallback URL if the original failed
+      try {
+        if (url) {
+          // Only try fallback if we were using a specific URL before
+          const fallbackUrl = getFallbackStoreUrl();
+          Logger.info(`Trying fallback store URL: ${fallbackUrl}`);
+          await Linking.openURL(fallbackUrl);
+          return true;
+        }
+      } catch (fallbackError) {
+        const fbMessage = fallbackError instanceof Error ? fallbackError.message : String(fallbackError);
+        Logger.error(`Failed to open fallback URL: ${fbMessage}`);
+      }
+      return false;
+    }
+  },
+  getFallbackStoreUrl
+};
+
+/**
+ * Custom hook to check for required app updates.
+ *
+ * @param isAppReady - Whether the app is ready to perform the check
+ * @param environment - The app environment (defaults to the one in config)
+ */
+export const useVersionCheck = (isAppReady, environment = getConfigValue('environment', 'Development')) => {
+  const [updateInfo, setUpdateInfo] = useState({
+    isUpdateRequired: false,
+    updateUrl: null
+  });
+  useEffect(() => {
+    let isMounted = true;
+    const checkVersion = async () => {
+      try {
+        // All retry logic is handled in the VersionCheck module
+        const {
+          isNewVersionAvailable,
+          url
+        } = await VersionCheck.isNewVersionAvailable();
+        if (isNewVersionAvailable && isMounted) {
+          Logger.info('Update required. URL:', url || 'Not available yet');
+          setUpdateInfo({
+            isUpdateRequired: true,
+            updateUrl: url
+          });
+        } else if (isMounted) {
+          Logger.info('App is up to date');
+        }
+      } catch (error) {
+        Logger.error('Error checking app version:', error);
+      }
+    };
+
+    // Only run version check in Production environment when app is ready
+    if (isAppReady && environment === 'Production') {
+      void checkVersion();
+    }
+    return () => {
+      isMounted = false;
+    };
+  }, [isAppReady, environment]);
+  return updateInfo;
+};
+
+// Export for backward compatibility
+export default VersionCheck;
+//# sourceMappingURL=index.js.map

package/lib/typescript/commonjs/api/baseUrl.d.ts

@@ -0,0 +1,20 @@
+import type { AxiosInstance } from 'axios';
+/**
+ * Resolves `baseURL` PER REQUEST rather than at module evaluation.
+ *
+ * `axios.create({ baseURL: getConfigValue('baseUrl') })` reads the value once,
+ * when the module is first imported — which happens the moment anything touches
+ * the package barrel, long before an app's startup code can call `setConfig`.
+ * The result was a client permanently pinned to `undefined` and a `setConfig`
+ * that appeared to do nothing, with no error anywhere: requests just went to a
+ * relative URL.
+ *
+ * A consumer cannot fix that by ordering its own imports, because the import
+ * that loses the race is usually one it never wrote. So the clients stop
+ * capturing the value and ask for it per request instead.
+ *
+ * An explicit per-request `baseURL` still wins, which is what keeps a one-off
+ * call to a different host possible.
+ */
+export declare const applyConfiguredBaseUrl: (client: AxiosInstance) => void;
+//# sourceMappingURL=baseUrl.d.ts.map

package/lib/typescript/commonjs/api/curl.d.ts

@@ -0,0 +1,18 @@
+import type { AxiosRequestConfig } from 'axios';
+/**
+ * Builds a copy-pasteable curl command for a request, with every credential
+ * replaced by a placeholder.
+ *
+ * The redaction is the point, not a nicety. An unredacted version of this in a
+ * consumer app put `Authorization: Bearer <token>` and the login request's
+ * plaintext password into the device console of a *release* staging build.
+ * A curl line is worth having; a curl line that has to be trusted not to be
+ * enabled in the wrong build is not.
+ */
+export declare const buildCurl: (config: AxiosRequestConfig) => string;
+/**
+ * Logs the curl equivalent of a request. Never throws: a failure to describe a
+ * request must not be able to fail the request itself.
+ */
+export declare const logCurl: (config: AxiosRequestConfig) => void;
+//# sourceMappingURL=curl.d.ts.map

package/lib/typescript/commonjs/api/publicClient.d.ts

@@ -0,0 +1,11 @@
+import { type AxiosInstance } from 'axios';
+/**
+ * Public Axios Client
+ * - Base URL: Set your public API base URL.
+ * - No Authorization header is attached.
+ * - Includes timeout configuration and error handling.
+ * - Handles specific HTTP status codes.
+ */
+declare const publicClient: AxiosInstance;
+export default publicClient;
+//# sourceMappingURL=publicClient.d.ts.map

package/lib/typescript/commonjs/api/retry.d.ts

@@ -0,0 +1,27 @@
+import type { AxiosError, AxiosInstance } from 'axios';
+export interface RetryPolicy {
+    retries?: number;
+    /** `attempt` is 1-based: 1 is the first retry, not the original request. */
+    retryDelayMs?: (attempt: number) => number;
+    shouldRetry?: (error: AxiosError) => boolean;
+    onRetry?: (attempt: number, error: AxiosError) => void;
+}
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        /** `false` opts a single request out of retrying; an object overrides the client policy. */
+        retry?: boolean | RetryPolicy;
+    }
+}
+/**
+ * Status-based ONLY, deliberately: a bare network error (no `error.response`)
+ * is never retryable. Both clients carry non-idempotent requests, login and OTP
+ * on the public one and every write on the user one, and a broken connection
+ * says nothing about whether the request reached the server. Retrying can
+ * therefore create a second session, or a duplicate record, that the user never
+ * sees. A generic network-error retry rule is not a substitute: it decides on
+ * the transport alone and never looks at the HTTP method, so it retries POSTs
+ * as readily as GETs.
+ */
+export declare const isRetryableStatus: (status: number | undefined) => boolean;
+export declare const attachRetry: (client: AxiosInstance, policy?: RetryPolicy) => void;
+//# sourceMappingURL=retry.d.ts.map