@timeback/core 0.1.3 → 0.1.5

package/dist/errors.js

@@ -1,20 +1,4 @@
-import { createRequire } from "node:module";
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -24,7 +8,417 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
-var __require = /* @__PURE__ */ createRequire(import.meta.url);
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// node:util
+var exports_util = {};
+__export(exports_util, {
+  types: () => types,
+  promisify: () => promisify,
+  log: () => log,
+  isUndefined: () => isUndefined,
+  isSymbol: () => isSymbol,
+  isString: () => isString,
+  isRegExp: () => isRegExp,
+  isPrimitive: () => isPrimitive,
+  isObject: () => isObject,
+  isNumber: () => isNumber,
+  isNullOrUndefined: () => isNullOrUndefined,
+  isNull: () => isNull,
+  isFunction: () => isFunction,
+  isError: () => isError,
+  isDate: () => isDate,
+  isBuffer: () => isBuffer,
+  isBoolean: () => isBoolean,
+  isArray: () => isArray,
+  inspect: () => inspect,
+  inherits: () => inherits,
+  format: () => format,
+  deprecate: () => deprecate,
+  default: () => util_default,
+  debuglog: () => debuglog,
+  callbackifyOnRejected: () => callbackifyOnRejected,
+  callbackify: () => callbackify,
+  _extend: () => _extend,
+  TextEncoder: () => TextEncoder,
+  TextDecoder: () => TextDecoder
+});
+function format(f, ...args) {
+  if (!isString(f)) {
+    var objects = [f];
+    for (var i = 0;i < args.length; i++)
+      objects.push(inspect(args[i]));
+    return objects.join(" ");
+  }
+  var i = 0, len = args.length, str = String(f).replace(formatRegExp, function(x2) {
+    if (x2 === "%%")
+      return "%";
+    if (i >= len)
+      return x2;
+    switch (x2) {
+      case "%s":
+        return String(args[i++]);
+      case "%d":
+        return Number(args[i++]);
+      case "%j":
+        try {
+          return JSON.stringify(args[i++]);
+        } catch (_) {
+          return "[Circular]";
+        }
+      default:
+        return x2;
+    }
+  });
+  for (var x = args[i];i < len; x = args[++i])
+    if (isNull(x) || !isObject(x))
+      str += " " + x;
+    else
+      str += " " + inspect(x);
+  return str;
+}
+function deprecate(fn, msg) {
+  if (typeof process > "u" || process?.noDeprecation === true)
+    return fn;
+  var warned = false;
+  function deprecated(...args) {
+    if (!warned) {
+      if (process.throwDeprecation)
+        throw Error(msg);
+      else if (process.traceDeprecation)
+        console.trace(msg);
+      else
+        console.error(msg);
+      warned = true;
+    }
+    return fn.apply(this, ...args);
+  }
+  return deprecated;
+}
+function stylizeWithColor(str, styleType) {
+  var style = inspect.styles[styleType];
+  if (style)
+    return "\x1B[" + inspect.colors[style][0] + "m" + str + "\x1B[" + inspect.colors[style][1] + "m";
+  else
+    return str;
+}
+function stylizeNoColor(str, styleType) {
+  return str;
+}
+function arrayToHash(array) {
+  var hash = {};
+  return array.forEach(function(val, idx) {
+    hash[val] = true;
+  }), hash;
+}
+function formatValue(ctx, value, recurseTimes) {
+  if (ctx.customInspect && value && isFunction(value.inspect) && value.inspect !== inspect && !(value.constructor && value.constructor.prototype === value)) {
+    var ret = value.inspect(recurseTimes, ctx);
+    if (!isString(ret))
+      ret = formatValue(ctx, ret, recurseTimes);
+    return ret;
+  }
+  var primitive = formatPrimitive(ctx, value);
+  if (primitive)
+    return primitive;
+  var keys = Object.keys(value), visibleKeys = arrayToHash(keys);
+  if (ctx.showHidden)
+    keys = Object.getOwnPropertyNames(value);
+  if (isError(value) && (keys.indexOf("message") >= 0 || keys.indexOf("description") >= 0))
+    return formatError(value);
+  if (keys.length === 0) {
+    if (isFunction(value)) {
+      var name = value.name ? ": " + value.name : "";
+      return ctx.stylize("[Function" + name + "]", "special");
+    }
+    if (isRegExp(value))
+      return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+    if (isDate(value))
+      return ctx.stylize(Date.prototype.toString.call(value), "date");
+    if (isError(value))
+      return formatError(value);
+  }
+  var base = "", array = false, braces = ["{", "}"];
+  if (isArray(value))
+    array = true, braces = ["[", "]"];
+  if (isFunction(value)) {
+    var n = value.name ? ": " + value.name : "";
+    base = " [Function" + n + "]";
+  }
+  if (isRegExp(value))
+    base = " " + RegExp.prototype.toString.call(value);
+  if (isDate(value))
+    base = " " + Date.prototype.toUTCString.call(value);
+  if (isError(value))
+    base = " " + formatError(value);
+  if (keys.length === 0 && (!array || value.length == 0))
+    return braces[0] + base + braces[1];
+  if (recurseTimes < 0)
+    if (isRegExp(value))
+      return ctx.stylize(RegExp.prototype.toString.call(value), "regexp");
+    else
+      return ctx.stylize("[Object]", "special");
+  ctx.seen.push(value);
+  var output;
+  if (array)
+    output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
+  else
+    output = keys.map(function(key) {
+      return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
+    });
+  return ctx.seen.pop(), reduceToSingleString(output, base, braces);
+}
+function formatPrimitive(ctx, value) {
+  if (isUndefined(value))
+    return ctx.stylize("undefined", "undefined");
+  if (isString(value)) {
+    var simple = "'" + JSON.stringify(value).replace(/^"|"$/g, "").replace(/'/g, "\\'").replace(/\\"/g, '"') + "'";
+    return ctx.stylize(simple, "string");
+  }
+  if (isNumber(value))
+    return ctx.stylize("" + value, "number");
+  if (isBoolean(value))
+    return ctx.stylize("" + value, "boolean");
+  if (isNull(value))
+    return ctx.stylize("null", "null");
+}
+function formatError(value) {
+  return "[" + Error.prototype.toString.call(value) + "]";
+}
+function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
+  var output = [];
+  for (var i = 0, l = value.length;i < l; ++i)
+    if (hasOwnProperty(value, String(i)))
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, String(i), true));
+    else
+      output.push("");
+  return keys.forEach(function(key) {
+    if (!key.match(/^\d+$/))
+      output.push(formatProperty(ctx, value, recurseTimes, visibleKeys, key, true));
+  }), output;
+}
+function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
+  var name, str, desc;
+  if (desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] }, desc.get)
+    if (desc.set)
+      str = ctx.stylize("[Getter/Setter]", "special");
+    else
+      str = ctx.stylize("[Getter]", "special");
+  else if (desc.set)
+    str = ctx.stylize("[Setter]", "special");
+  if (!hasOwnProperty(visibleKeys, key))
+    name = "[" + key + "]";
+  if (!str)
+    if (ctx.seen.indexOf(desc.value) < 0) {
+      if (isNull(recurseTimes))
+        str = formatValue(ctx, desc.value, null);
+      else
+        str = formatValue(ctx, desc.value, recurseTimes - 1);
+      if (str.indexOf(`
+`) > -1)
+        if (array)
+          str = str.split(`
+`).map(function(line) {
+            return "  " + line;
+          }).join(`
+`).slice(2);
+        else
+          str = `
+` + str.split(`
+`).map(function(line) {
+            return "   " + line;
+          }).join(`
+`);
+    } else
+      str = ctx.stylize("[Circular]", "special");
+  if (isUndefined(name)) {
+    if (array && key.match(/^\d+$/))
+      return str;
+    if (name = JSON.stringify("" + key), name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/))
+      name = name.slice(1, -1), name = ctx.stylize(name, "name");
+    else
+      name = name.replace(/'/g, "\\'").replace(/\\"/g, '"').replace(/(^"|"$)/g, "'"), name = ctx.stylize(name, "string");
+  }
+  return name + ": " + str;
+}
+function reduceToSingleString(output, base, braces) {
+  var numLinesEst = 0, length = output.reduce(function(prev, cur) {
+    if (numLinesEst++, cur.indexOf(`
+`) >= 0)
+      numLinesEst++;
+    return prev + cur.replace(/\u001b\[\d\d?m/g, "").length + 1;
+  }, 0);
+  if (length > 60)
+    return braces[0] + (base === "" ? "" : base + `
+ `) + " " + output.join(`,
+  `) + " " + braces[1];
+  return braces[0] + base + " " + output.join(", ") + " " + braces[1];
+}
+function isArray(ar) {
+  return Array.isArray(ar);
+}
+function isBoolean(arg) {
+  return typeof arg === "boolean";
+}
+function isNull(arg) {
+  return arg === null;
+}
+function isNullOrUndefined(arg) {
+  return arg == null;
+}
+function isNumber(arg) {
+  return typeof arg === "number";
+}
+function isString(arg) {
+  return typeof arg === "string";
+}
+function isSymbol(arg) {
+  return typeof arg === "symbol";
+}
+function isUndefined(arg) {
+  return arg === undefined;
+}
+function isRegExp(re) {
+  return isObject(re) && objectToString(re) === "[object RegExp]";
+}
+function isObject(arg) {
+  return typeof arg === "object" && arg !== null;
+}
+function isDate(d) {
+  return isObject(d) && objectToString(d) === "[object Date]";
+}
+function isError(e) {
+  return isObject(e) && (objectToString(e) === "[object Error]" || e instanceof Error);
+}
+function isFunction(arg) {
+  return typeof arg === "function";
+}
+function isPrimitive(arg) {
+  return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || typeof arg > "u";
+}
+function isBuffer(arg) {
+  return arg instanceof Buffer;
+}
+function objectToString(o) {
+  return Object.prototype.toString.call(o);
+}
+function pad(n) {
+  return n < 10 ? "0" + n.toString(10) : n.toString(10);
+}
+function timestamp() {
+  var d = new Date, time = [pad(d.getHours()), pad(d.getMinutes()), pad(d.getSeconds())].join(":");
+  return [d.getDate(), months[d.getMonth()], time].join(" ");
+}
+function log(...args) {
+  console.log("%s - %s", timestamp(), format.apply(null, args));
+}
+function inherits(ctor, superCtor) {
+  if (superCtor)
+    ctor.super_ = superCtor, ctor.prototype = Object.create(superCtor.prototype, { constructor: { value: ctor, enumerable: false, writable: true, configurable: true } });
+}
+function _extend(origin, add) {
+  if (!add || !isObject(add))
+    return origin;
+  var keys = Object.keys(add), i = keys.length;
+  while (i--)
+    origin[keys[i]] = add[keys[i]];
+  return origin;
+}
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+function callbackifyOnRejected(reason, cb) {
+  if (!reason) {
+    var newReason = Error("Promise was rejected with a falsy value");
+    newReason.reason = reason, reason = newReason;
+  }
+  return cb(reason);
+}
+function callbackify(original) {
+  if (typeof original !== "function")
+    throw TypeError('The "original" argument must be of type Function');
+  function callbackified(...args) {
+    var maybeCb = args.pop();
+    if (typeof maybeCb !== "function")
+      throw TypeError("The last argument must be of type Function");
+    var self = this, cb = function(...args2) {
+      return maybeCb.apply(self, ...args2);
+    };
+    original.apply(this, args).then(function(ret) {
+      process.nextTick(cb.bind(null, null, ret));
+    }, function(rej) {
+      process.nextTick(callbackifyOnRejected.bind(null, rej, cb));
+    });
+  }
+  return Object.setPrototypeOf(callbackified, Object.getPrototypeOf(original)), Object.defineProperties(callbackified, Object.getOwnPropertyDescriptors(original)), callbackified;
+}
+var formatRegExp, debuglog, inspect, types = () => {}, months, promisify, TextEncoder, TextDecoder, util_default;
+var init_util = __esm(() => {
+  formatRegExp = /%[sdj%]/g;
+  debuglog = ((debugs = {}, debugEnvRegex = {}, debugEnv) => ((debugEnv = typeof process < "u" && false) && (debugEnv = debugEnv.replace(/[|\\{}()[\]^$+?.]/g, "\\$&").replace(/\*/g, ".*").replace(/,/g, "$|^").toUpperCase()), debugEnvRegex = new RegExp("^" + debugEnv + "$", "i"), (set) => {
+    if (set = set.toUpperCase(), !debugs[set])
+      if (debugEnvRegex.test(set))
+        debugs[set] = function(...args) {
+          console.error("%s: %s", set, pid, format.apply(null, ...args));
+        };
+      else
+        debugs[set] = function() {};
+    return debugs[set];
+  }))();
+  inspect = ((i) => (i.colors = { bold: [1, 22], italic: [3, 23], underline: [4, 24], inverse: [7, 27], white: [37, 39], grey: [90, 39], black: [30, 39], blue: [34, 39], cyan: [36, 39], green: [32, 39], magenta: [35, 39], red: [31, 39], yellow: [33, 39] }, i.styles = { special: "cyan", number: "yellow", boolean: "yellow", undefined: "grey", null: "bold", string: "green", date: "magenta", regexp: "red" }, i.custom = Symbol.for("nodejs.util.inspect.custom"), i))(function(obj, opts, ...rest) {
+    var ctx = { seen: [], stylize: stylizeNoColor };
+    if (rest.length >= 1)
+      ctx.depth = rest[0];
+    if (rest.length >= 2)
+      ctx.colors = rest[1];
+    if (isBoolean(opts))
+      ctx.showHidden = opts;
+    else if (opts)
+      _extend(ctx, opts);
+    if (isUndefined(ctx.showHidden))
+      ctx.showHidden = false;
+    if (isUndefined(ctx.depth))
+      ctx.depth = 2;
+    if (isUndefined(ctx.colors))
+      ctx.colors = false;
+    if (ctx.colors)
+      ctx.stylize = stylizeWithColor;
+    return formatValue(ctx, obj, ctx.depth);
+  });
+  months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  promisify = ((x) => (x.custom = Symbol.for("nodejs.util.promisify.custom"), x))(function(original) {
+    if (typeof original !== "function")
+      throw TypeError('The "original" argument must be of type Function');
+    if (kCustomPromisifiedSymbol && original[kCustomPromisifiedSymbol]) {
+      var fn = original[kCustomPromisifiedSymbol];
+      if (typeof fn !== "function")
+        throw TypeError('The "nodejs.util.promisify.custom" argument must be of type Function');
+      return Object.defineProperty(fn, kCustomPromisifiedSymbol, { value: fn, enumerable: false, writable: false, configurable: true }), fn;
+    }
+    function fn(...args) {
+      var promiseResolve, promiseReject, promise = new Promise(function(resolve, reject) {
+        promiseResolve = resolve, promiseReject = reject;
+      });
+      args.push(function(err, value) {
+        if (err)
+          promiseReject(err);
+        else
+          promiseResolve(value);
+      });
+      try {
+        original.apply(this, args);
+      } catch (err) {
+        promiseReject(err);
+      }
+      return promise;
+    }
+    if (Object.setPrototypeOf(fn, Object.getPrototypeOf(original)), kCustomPromisifiedSymbol)
+      Object.defineProperty(fn, kCustomPromisifiedSymbol, { value: fn, enumerable: false, writable: false, configurable: true });
+    return Object.defineProperties(fn, Object.getOwnPropertyDescriptors(original));
+  });
+  ({ TextEncoder, TextDecoder } = globalThis);
+  util_default = { TextEncoder, TextDecoder, promisify, log, inherits, _extend, callbackifyOnRejected, callbackify };
+});
 
 // ../../internal/constants/src/endpoints.ts
 var DEFAULT_PLATFORM = "BEYOND_AI";
@@ -180,7 +574,7 @@ function detectEnvironment() {
 var nodeInspect;
 if (!isBrowser()) {
   try {
-    const util = await import("node:util");
+    const util = await Promise.resolve().then(() => (init_util(), exports_util));
     nodeInspect = util.inspect;
   } catch {}
 }
@@ -233,10 +627,10 @@ var terminalFormatter = (entry) => {
   const consoleMethod = getConsoleMethod(entry.level);
   const levelUpper = entry.level.toUpperCase().padEnd(5);
   const isoString = entry.timestamp.toISOString().replace(/\.\d{3}Z$/, "");
-  const timestamp = `${colors.dim}[${isoString}]${colors.reset}`;
+  const timestamp2 = `${colors.dim}[${isoString}]${colors.reset}`;
   const level = `${levelColor}${levelUpper}${colors.reset}`;
   const scope = entry.scope ? `${colors.bold}[${entry.scope}]${colors.reset} ` : "";
-  const prefix = `${timestamp} ${level} ${scope}${entry.message}`;
+  const prefix = `${timestamp2} ${level} ${scope}${entry.message}`;
   if (entry.context && Object.keys(entry.context).length > 0) {
     consoleMethod(prefix, formatContext(entry.context));
   } else {
@@ -251,9 +645,9 @@ var LEVEL_PREFIX = {
   error: "[ERROR]"
 };
 function formatContext2(context) {
-  return Object.entries(context).map(([key, value]) => `${key}=${formatValue(value)}`).join(" ");
+  return Object.entries(context).map(([key, value]) => `${key}=${formatValue2(value)}`).join(" ");
 }
-function formatValue(value) {
+function formatValue2(value) {
   if (typeof value === "string")
     return value;
   if (typeof value === "number")
@@ -413,7 +807,7 @@ function isDebug() {
     return false;
   }
 }
-var log = createLogger({ scope: "auth", minLevel: isDebug() ? "debug" : "warn" });
+var log2 = createLogger({ scope: "auth", minLevel: isDebug() ? "debug" : "warn" });
 
 class TokenManager {
   config;
@@ -427,11 +821,11 @@ class TokenManager {
   }
   async getToken() {
     if (this.accessToken && Date.now() < this.tokenExpiry) {
-      log.debug("Using cached token");
+      log2.debug("Using cached token");
       return this.accessToken;
     }
     if (this.pendingRequest) {
-      log.debug("Waiting for in-flight token request");
+      log2.debug("Waiting for in-flight token request");
       return this.pendingRequest;
     }
     this.pendingRequest = this.fetchToken();
@@ -442,7 +836,7 @@ class TokenManager {
     }
   }
   async fetchToken() {
-    log.debug("Fetching new access token...");
+    log2.debug("Fetching new access token...");
     const { clientId, clientSecret } = this.config.credentials;
     const credentials = btoa(`${clientId}:${clientSecret}`);
     const start = performance.now();
@@ -456,17 +850,17 @@ class TokenManager {
     });
     const duration = Math.round(performance.now() - start);
     if (!response.ok) {
-      log.error(`Token request failed: ${response.status} ${response.statusText}`);
+      log2.error(`Token request failed: ${response.status} ${response.statusText}`);
       throw new Error(`Failed to obtain access token: ${response.status} ${response.statusText}`);
     }
     const data = await response.json();
     this.accessToken = data.access_token;
     this.tokenExpiry = Date.now() + (data.expires_in - 60) * 1000;
-    log.debug(`Token acquired (${duration}ms, expires in ${data.expires_in}s)`);
+    log2.debug(`Token acquired (${duration}ms, expires in ${data.expires_in}s)`);
     return this.accessToken;
   }
   invalidate() {
-    log.debug("Token invalidated");
+    log2.debug("Token invalidated");
     this.accessToken = null;
     this.tokenExpiry = 0;
   }
@@ -704,7 +1098,17 @@ class TimebackProvider {
 // ../../internal/client-infra/src/utils/utils.ts
 function getEnv(key) {
   try {
-    return typeof process === "undefined" ? undefined : process.env[key];
+    if (typeof process === "undefined")
+      return;
+    if (typeof key === "string") {
+      return process.env[key];
+    }
+    for (const k of key) {
+      const value = process.env[k];
+      if (value !== undefined)
+        return value;
+    }
+    return;
   } catch {
     return;
   }
@@ -725,6 +1129,18 @@ var DEFAULT_PROVIDER_REGISTRY = {
 };
 
 // ../../internal/client-infra/src/config/resolve.ts
+function primaryEnvVar(key) {
+  if (typeof key === "string") {
+    return key;
+  }
+  if (key.length === 0) {
+    throw new Error(`Missing env var key: ${key}`);
+  }
+  return key[0];
+}
+function formatEnvVarKey(key) {
+  return primaryEnvVar(key);
+}
 function validateEnv(env) {
   if (env !== "staging" && env !== "production") {
     throw new Error(`Invalid env "${env}": must be "staging" or "production"`);
@@ -735,10 +1151,10 @@ function validateAuth(auth, envVars) {
   const clientId = auth?.clientId ?? getEnv(envVars.clientId);
   const clientSecret = auth?.clientSecret ?? getEnv(envVars.clientSecret);
   if (!clientId) {
-    throw new Error(`Missing clientId: provide in config or set ${envVars.clientId}`);
+    throw new Error(`Missing clientId: provide in config or set ${formatEnvVarKey(envVars.clientId)}`);
   }
   if (!clientSecret) {
-    throw new Error(`Missing clientSecret: provide in config or set ${envVars.clientSecret}`);
+    throw new Error(`Missing clientSecret: provide in config or set ${formatEnvVarKey(envVars.clientSecret)}`);
   }
   return { clientId, clientSecret };
 }
@@ -754,21 +1170,21 @@ function buildMissingEnvError(envVars) {
   const clientId = getEnv(envVars.clientId);
   const clientSecret = getEnv(envVars.clientSecret);
   if (baseUrl === undefined && clientId === undefined) {
-    const hint = envVars.env ?? envVars.baseUrl;
+    const hint = formatEnvVarKey(envVars.env ?? envVars.baseUrl);
     return `Missing env: provide in config or set ${hint}`;
   }
   const missing = [];
   if (baseUrl === undefined) {
-    missing.push(envVars.env ?? envVars.baseUrl);
+    missing.push(formatEnvVarKey(envVars.env ?? envVars.baseUrl));
   }
   if (baseUrl !== undefined && authUrl === undefined) {
-    missing.push(envVars.authUrl);
+    missing.push(formatEnvVarKey(envVars.authUrl));
   }
   if (clientId === undefined) {
-    missing.push(envVars.clientId);
+    missing.push(formatEnvVarKey(envVars.clientId));
   }
   if (clientSecret === undefined) {
-    missing.push(envVars.clientSecret);
+    missing.push(formatEnvVarKey(envVars.clientSecret));
   }
   return `Missing environment variables: ${missing.join(", ")}`;
 }
@@ -998,43 +1414,43 @@ function escapeValue(value) {
   }
   return value.replaceAll("'", "''");
 }
-function formatValue2(value) {
+function formatValue3(value) {
   const escaped = escapeValue(value);
   const needsQuotes = typeof value === "string" || value instanceof Date;
   return needsQuotes ? `'${escaped}'` : escaped;
 }
 function fieldToConditions(field, condition) {
   if (typeof condition === "string" || typeof condition === "number" || typeof condition === "boolean" || condition instanceof Date) {
-    return [`${field}=${formatValue2(condition)}`];
+    return [`${field}=${formatValue3(condition)}`];
   }
   if (typeof condition === "object" && condition !== null) {
     const ops = condition;
     const conditions = [];
     if (ops.ne !== undefined) {
-      conditions.push(`${field}!=${formatValue2(ops.ne)}`);
+      conditions.push(`${field}!=${formatValue3(ops.ne)}`);
     }
     if (ops.gt !== undefined) {
-      conditions.push(`${field}>${formatValue2(ops.gt)}`);
+      conditions.push(`${field}>${formatValue3(ops.gt)}`);
     }
     if (ops.gte !== undefined) {
-      conditions.push(`${field}>=${formatValue2(ops.gte)}`);
+      conditions.push(`${field}>=${formatValue3(ops.gte)}`);
     }
     if (ops.lt !== undefined) {
-      conditions.push(`${field}<${formatValue2(ops.lt)}`);
+      conditions.push(`${field}<${formatValue3(ops.lt)}`);
     }
     if (ops.lte !== undefined) {
-      conditions.push(`${field}<=${formatValue2(ops.lte)}`);
+      conditions.push(`${field}<=${formatValue3(ops.lte)}`);
     }
     if (ops.contains !== undefined) {
-      conditions.push(`${field}~${formatValue2(ops.contains)}`);
+      conditions.push(`${field}~${formatValue3(ops.contains)}`);
     }
     if (ops.in !== undefined && ops.in.length > 0) {
-      const inConditions = ops.in.map((v) => `${field}=${formatValue2(v)}`);
+      const inConditions = ops.in.map((v) => `${field}=${formatValue3(v)}`);
       const joined = inConditions.join(" OR ");
       conditions.push(inConditions.length > 1 ? `(${joined})` : joined);
     }
     if (ops.notIn !== undefined && ops.notIn.length > 0) {
-      const notInConditions = ops.notIn.map((v) => `${field}!=${formatValue2(v)}`);
+      const notInConditions = ops.notIn.map((v) => `${field}!=${formatValue3(v)}`);
       conditions.push(notInConditions.join(" AND "));
     }
     return conditions;

package/dist/index.d.ts

@@ -24,6 +24,7 @@ export type { BroadcastResult, BroadcastResultMethods, BroadcastResults } from '
 export { ApiError, ForbiddenError, isApiError, NotFoundError, UnauthorizedError, ValidationError, } from '@timeback/internal-client-infra';
 export { whereToFilter } from '@timeback/internal-client-infra';
 export type { FieldCondition, FieldOperators, FilterValue, OrCondition, WhereClause, } from '@timeback/internal-client-infra';
-export type { Environment, TimebackClientConfig } from './types/index';
+export { getServiceUrlsForEnv } from './constants';
+export type { Environment, EnvServiceUrls, TimebackClientConfig } from './types/index';
 export type { AuthCheckResult } from '@timeback/internal-client-infra';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAM9F,OAAO,EACN,QAAQ,EACR,cAAc,EACd,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,GACf,MAAM,iCAAiC,CAAA;AAMxC,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAE/D,YAAY,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,WAAW,GACX,MAAM,iCAAiC,CAAA;AAMxC,YAAY,EAAE,WAAW,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAEtE,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAMH,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAA;AAC3C,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAM9F,OAAO,EACN,QAAQ,EACR,cAAc,EACd,UAAU,EACV,aAAa,EACb,iBAAiB,EACjB,eAAe,GACf,MAAM,iCAAiC,CAAA;AAMxC,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAE/D,YAAY,EACX,cAAc,EACd,cAAc,EACd,WAAW,EACX,WAAW,EACX,WAAW,GACX,MAAM,iCAAiC,CAAA;AAMxC,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAMlD,YAAY,EAAE,WAAW,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AAEtF,YAAY,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAA"}