wapi-client 0.18.0-beta.2 → 0.18.0-beta.3

package/dist/lib/utils.cjs

@@ -0,0 +1,344 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  checkCopyObject: () => checkCopyObject,
+  convertToNumber: () => convertToNumber,
+  convertToString: () => convertToString,
+  copyObject: () => copyObject,
+  getBasicAuth: () => getBasicAuth,
+  getConnectionParams: () => getConnectionParams,
+  getConnectionUrl: () => getConnectionUrl,
+  getIdentifier: () => getIdentifier,
+  getRandomHex: () => getRandomHex,
+  getTxIdSync: () => getTxIdSync,
+  isDate: () => isDate,
+  isDateTime: () => isDateTime,
+  isFutureDate: () => isFutureDate,
+  mergeFnOptions: () => mergeFnOptions,
+  mergeFnOptionsOrderBy: () => mergeFnOptionsOrderBy,
+  modifyObject: () => modifyObject,
+  orderByToOrder: () => orderByToOrder,
+  toQueryString: () => toQueryString,
+  wait: () => wait
+});
+module.exports = __toCommonJS(utils_exports);
+var import_errors = require("./errors.cjs");
+
+// node_modules/uuid/dist/esm/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/uuid/dist/esm/rng.js
+var import_crypto = require("crypto");
+var rnds8Pool = new Uint8Array(256);
+var poolPtr = rnds8Pool.length;
+function rng() {
+  if (poolPtr > rnds8Pool.length - 16) {
+    (0, import_crypto.randomFillSync)(rnds8Pool);
+    poolPtr = 0;
+  }
+  return rnds8Pool.slice(poolPtr, poolPtr += 16);
+}
+
+// node_modules/uuid/dist/esm/native.js
+var import_crypto2 = require("crypto");
+var native_default = { randomUUID: import_crypto2.randomUUID };
+
+// node_modules/uuid/dist/esm/v4.js
+function v4(options, buf, offset) {
+  var _a, _b, _c;
+  if (native_default.randomUUID && !buf && !options) {
+    return native_default.randomUUID();
+  }
+  options = options || {};
+  const rnds = (_c = (_b = options.random) != null ? _b : (_a = options.rng) == null ? void 0 : _a.call(options)) != null ? _c : rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// src/lib/utils.ts
+var internalMap = {
+  timeouts: {},
+  values: {},
+  set(key, value) {
+    this.timeouts[key] = setTimeout(() => this.clear(key), 3e4);
+    this.values[key] = value;
+  },
+  get(key) {
+    return this.values[key];
+  },
+  getKey(object) {
+    const copy = JSON.parse(JSON.stringify(object));
+    let toHash = "";
+    Object.keys(copy).sort().forEach((key) => {
+      let value = "";
+      if (copy[key] && typeof copy[key] === "object" && !Array.isArray(copy[key])) {
+        value = this.getKey(copy[key]);
+      } else {
+        value = JSON.stringify(copy[key]);
+      }
+      toHash += key + ":" + value;
+    });
+    return toHash;
+  },
+  clear(key) {
+    if (this.timeouts[key]) {
+      clearTimeout(this.timeouts[key]);
+    }
+    delete this.timeouts[key];
+    delete this.values[key];
+  },
+  clearAll() {
+    Object.keys(this.timeouts).forEach((key) => {
+      clearTimeout(this.timeouts[key]);
+    });
+    this.timeouts = {};
+    this.values = {};
+  }
+};
+function getRandomHex(length = 8) {
+  return v4_default().replace(/-/g, "").slice(-length);
+}
+function getTxIdSync(object) {
+  if (!object) {
+    return v4_default();
+  }
+  const key = internalMap.getKey(object);
+  if (internalMap.get(key)) {
+    throw new import_errors.InputError("INPUT_NEEDS_IDENTIFIER", { object });
+  }
+  const value = v4_default();
+  internalMap.set(key, value);
+  return value;
+}
+function wait(time2) {
+  return new Promise((r) => setTimeout(r, time2));
+}
+function getIdentifier() {
+  return getTxIdSync();
+}
+function copyObject(input) {
+  return JSON.parse(JSON.stringify(input));
+}
+function checkCopyObject(input, property, value) {
+  if (property in input) {
+    if (input[property] === void 0) {
+      throw new import_errors.ValidationError(
+        { input },
+        `undefined provided for ${property}`
+      );
+    }
+    return input;
+  }
+  if (!value) {
+    throw new import_errors.ValidationError(
+      { input },
+      `${property} is required if no default set`
+    );
+  }
+  const copy = copyObject(input);
+  copy[property] = value;
+  return copy;
+}
+function toQueryString(obj) {
+  return Object.keys(obj).filter((key) => obj[key] !== void 0).map(
+    (key) => `${encodeURIComponent(key)}=${encodeURIComponent(obj[key])}`
+  ).join("&");
+}
+function getConnectionUrl(config) {
+  const url = config.host.replace(/^https:/, "wss:");
+  return url + "?" + toQueryString(__spreadValues(__spreadValues({
+    db: config.database,
+    clientVersion: config.clientVersion,
+    connectionName: config.connectionName
+  }, "jwt" in config ? { jwt: config.jwt } : {}), "apikey" in config ? { apikey: config.apikey, apisecret: config.apisecret } : {}));
+}
+function getBasicAuth({
+  apikey,
+  apisecret,
+  database
+}) {
+  return btoa(`${database != null ? database : ""}:${apikey}:${apisecret}`);
+}
+function getConnectionParams(config) {
+  if (typeof window === "undefined") {
+    return [
+      getConnectionUrl(config),
+      {
+        rejectUnauthorized: config.rejectUnauthorized
+      }
+    ];
+  }
+  return [getConnectionUrl(config)];
+}
+function modifyObject(orig, modifications) {
+  const copy = {};
+  const original = !orig || typeof orig !== "object" ? {} : orig;
+  Object.keys(original).forEach((prop) => {
+    if (!modifications[prop]) {
+      copy[prop] = original[prop];
+    } else if (typeof modifications[prop] === "string") {
+      copy[modifications[prop]] = original[prop];
+    } else {
+      copy[prop] = modifications[prop](original[prop]);
+    }
+  });
+  return copy;
+}
+function orderByToOrder(orderBy) {
+  return orderBy.split(",").map((str) => str.split(" ")).map((split) => {
+    const [field, direction, nulls, nullsDirection] = split;
+    return __spreadValues({
+      field,
+      direction: direction === "desc" ? "desc" : "asc"
+    }, nulls === "nulls" && ["first", "last"].includes(nullsDirection) ? { nulls: nullsDirection } : {});
+  });
+}
+function mergeFnOptions(input, options) {
+  var _b;
+  const _a = input != null ? input : {}, { options: inputOptions } = _a, filter = __objRest(_a, ["options"]);
+  return {
+    filter,
+    options: (_b = options != null ? options : inputOptions) != null ? _b : {}
+  };
+}
+function mergeFnOptionsOrderBy(options) {
+  const _a = options, { order_by: orderBy } = _a, outputOptions = __objRest(_a, ["order_by"]);
+  if (!outputOptions.order && orderBy) {
+    outputOptions.order = orderByToOrder(orderBy);
+  }
+  return outputOptions;
+}
+function convertToString(input) {
+  if (input === void 0 || input === null) {
+    return;
+  }
+  return input + "";
+}
+function convertToNumber(input) {
+  if (typeof input === "number") {
+    return input;
+  }
+  return parseFloat(input);
+}
+function isFutureDate(dateString) {
+  return new Date(dateString).setHours(0, 0, 0, 0) > (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+}
+function isLeapYear(year) {
+  return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+}
+var DATE = /^(\d\d\d\d)-(\d\d)-(\d\d)$/;
+var DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+function isDate(str) {
+  const matches = DATE.exec(str);
+  if (!matches) return false;
+  const year = +matches[1];
+  const month = +matches[2];
+  const day = +matches[3];
+  return month >= 1 && month <= 12 && day >= 1 && day <= (month === 2 && isLeapYear(year) ? 29 : DAYS[month]);
+}
+var TIME = /^(\d\d):(\d\d):(\d\d)(\.\d+)?(z|[+-]\d\d(?::?\d\d)?)?$/i;
+function time(str, withTimeZone) {
+  const matches = TIME.exec(str);
+  if (!matches) return false;
+  const hour = +matches[1];
+  const minute = +matches[2];
+  const second = +matches[3];
+  const timeZone = matches[5];
+  return (hour <= 23 && minute <= 59 && second <= 59 || hour === 23 && minute === 59 && second === 60) && (!withTimeZone || timeZone !== "");
+}
+var DATE_TIME_SEPARATOR = /t|\s/i;
+function isDateTime(str) {
+  const dateTime = str.split(DATE_TIME_SEPARATOR);
+  if (dateTime.length === 1) {
+    return isDate(dateTime[0]);
+  }
+  return dateTime.length === 2 && isDate(dateTime[0]) && time(dateTime[1]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkCopyObject,
+  convertToNumber,
+  convertToString,
+  copyObject,
+  getBasicAuth,
+  getConnectionParams,
+  getConnectionUrl,
+  getIdentifier,
+  getRandomHex,
+  getTxIdSync,
+  isDate,
+  isDateTime,
+  isFutureDate,
+  mergeFnOptions,
+  mergeFnOptionsOrderBy,
+  modifyObject,
+  orderByToOrder,
+  toQueryString,
+  wait
+});

package/dist/lib/validation.browser.cjs

@@ -0,0 +1,125 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  getValidator: () => getValidator,
+  getValidatorError: () => getValidatorError,
+  hardValidate: () => hardValidate,
+  hardValidateWOptions: () => hardValidateWOptions,
+  softValidate: () => softValidate,
+  softValidateWOptions: () => softValidateWOptions
+});
+module.exports = __toCommonJS(validation_exports);
+var import_debug = require("./debug.browser.cjs");
+var import_zod = require("zod");
+var import_log = require("./log.browser.cjs");
+var import_errors = require("./errors.browser.cjs");
+var getValidatorError = (error, _input) => {
+  if (!error) {
+    return void 0;
+  }
+  const tree = import_zod.z.treeifyError(error);
+  const pretty = import_zod.z.prettifyError(error);
+  return new import_errors.ValidationError({
+    message: pretty,
+    data: tree
+  });
+};
+var softValidate = (schema, input, formatError = getValidatorError) => {
+  const { success, error, data } = schema.safeParse(input);
+  return {
+    data,
+    success,
+    isValid: success,
+    error: formatError(error, input)
+  };
+};
+var softValidateWOptions = (schema, input, options, formatError) => {
+  if (!input || typeof input !== "object") {
+    return {
+      success: false,
+      isValid: false,
+      error: new import_errors.ValidationError({
+        message: `Invalid input - expected object, got ${typeof input}`,
+        data: { input }
+      })
+    };
+  }
+  return softValidate(
+    schema,
+    __spreadValues({
+      options: options != null ? options : {}
+    }, input),
+    formatError
+  );
+};
+var hardValidate = (schema, input, log, formatError) => {
+  var _a;
+  const { data, error } = softValidate(schema, input, formatError);
+  if (error) {
+    ((_a = log == null ? void 0 : log.warn) != null ? _a : import_debug.debugLog)(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    throw error;
+  }
+  return data;
+};
+var hardValidateWOptions = (schema, input, options, log, formatError) => {
+  if (!log && options && typeof (options == null ? void 0 : options.warn) === "function") {
+    log = options;
+    options = {};
+  }
+  const { data, error } = softValidateWOptions(
+    schema,
+    input,
+    options,
+    formatError
+  );
+  if (error) {
+    if (log) {
+      log.warn(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    } else {
+      (0, import_debug.debugLog)(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    }
+    throw error;
+  }
+  return data;
+};
+var getValidator = (schema, formatError) => {
+  return {
+    validateInput: (input, log) => hardValidate(schema, input, log, formatError),
+    validateInputWOptions: (input, options, log) => hardValidateWOptions(schema, input, options, log, formatError),
+    softValidateInput: (input) => softValidate(schema, input, formatError),
+    softValidateWOptions: (input, options) => softValidateWOptions(schema, input, options, formatError)
+  };
+};

package/dist/lib/validation.browser.js

@@ -0,0 +1,107 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+
+// src/lib/validation.ts
+import { debugLog } from "./debug.browser.js";
+import { z } from "zod";
+import { QUERYABLE } from "./log.browser.js";
+import { ValidationError } from "./errors.browser.js";
+var getValidatorError = (error, _input) => {
+  if (!error) {
+    return void 0;
+  }
+  const tree = z.treeifyError(error);
+  const pretty = z.prettifyError(error);
+  return new ValidationError({
+    message: pretty,
+    data: tree
+  });
+};
+var softValidate = (schema, input, formatError = getValidatorError) => {
+  const { success, error, data } = schema.safeParse(input);
+  return {
+    data,
+    success,
+    isValid: success,
+    error: formatError(error, input)
+  };
+};
+var softValidateWOptions = (schema, input, options, formatError) => {
+  if (!input || typeof input !== "object") {
+    return {
+      success: false,
+      isValid: false,
+      error: new ValidationError({
+        message: `Invalid input - expected object, got ${typeof input}`,
+        data: { input }
+      })
+    };
+  }
+  return softValidate(
+    schema,
+    __spreadValues({
+      options: options != null ? options : {}
+    }, input),
+    formatError
+  );
+};
+var hardValidate = (schema, input, log, formatError) => {
+  var _a;
+  const { data, error } = softValidate(schema, input, formatError);
+  if (error) {
+    ((_a = log == null ? void 0 : log.warn) != null ? _a : debugLog)(__spreadValues({ err: error }, QUERYABLE), "Invalid input");
+    throw error;
+  }
+  return data;
+};
+var hardValidateWOptions = (schema, input, options, log, formatError) => {
+  if (!log && options && typeof (options == null ? void 0 : options.warn) === "function") {
+    log = options;
+    options = {};
+  }
+  const { data, error } = softValidateWOptions(
+    schema,
+    input,
+    options,
+    formatError
+  );
+  if (error) {
+    if (log) {
+      log.warn(__spreadValues({ err: error }, QUERYABLE), "Invalid input");
+    } else {
+      debugLog(__spreadValues({ err: error }, QUERYABLE), "Invalid input");
+    }
+    throw error;
+  }
+  return data;
+};
+var getValidator = (schema, formatError) => {
+  return {
+    validateInput: (input, log) => hardValidate(schema, input, log, formatError),
+    validateInputWOptions: (input, options, log) => hardValidateWOptions(schema, input, options, log, formatError),
+    softValidateInput: (input) => softValidate(schema, input, formatError),
+    softValidateWOptions: (input, options) => softValidateWOptions(schema, input, options, formatError)
+  };
+};
+export {
+  getValidator,
+  getValidatorError,
+  hardValidate,
+  hardValidateWOptions,
+  softValidate,
+  softValidateWOptions
+};

package/dist/lib/validation.cjs

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  getValidator: () => getValidator,
+  getValidatorError: () => getValidatorError,
+  hardValidate: () => hardValidate,
+  hardValidateWOptions: () => hardValidateWOptions,
+  softValidate: () => softValidate,
+  softValidateWOptions: () => softValidateWOptions
+});
+module.exports = __toCommonJS(validation_exports);
+var import_debug = require("./debug.cjs");
+var import_zod = require("zod");
+var import_log = require("./log.cjs");
+var import_errors = require("./errors.cjs");
+var getValidatorError = (error, _input) => {
+  if (!error) {
+    return void 0;
+  }
+  const tree = import_zod.z.treeifyError(error);
+  const pretty = import_zod.z.prettifyError(error);
+  return new import_errors.ValidationError({
+    message: pretty,
+    data: tree
+  });
+};
+var softValidate = (schema, input, formatError = getValidatorError) => {
+  const { success, error, data } = schema.safeParse(input);
+  return {
+    data,
+    success,
+    isValid: success,
+    error: formatError(error, input)
+  };
+};
+var softValidateWOptions = (schema, input, options, formatError) => {
+  if (!input || typeof input !== "object") {
+    return {
+      success: false,
+      isValid: false,
+      error: new import_errors.ValidationError({
+        message: `Invalid input - expected object, got ${typeof input}`,
+        data: { input }
+      })
+    };
+  }
+  return softValidate(
+    schema,
+    __spreadValues({
+      options: options != null ? options : {}
+    }, input),
+    formatError
+  );
+};
+var hardValidate = (schema, input, log, formatError) => {
+  var _a;
+  const { data, error } = softValidate(schema, input, formatError);
+  if (error) {
+    ((_a = log == null ? void 0 : log.warn) != null ? _a : import_debug.debugLog)(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    throw error;
+  }
+  return data;
+};
+var hardValidateWOptions = (schema, input, options, log, formatError) => {
+  if (!log && options && typeof (options == null ? void 0 : options.warn) === "function") {
+    log = options;
+    options = {};
+  }
+  const { data, error } = softValidateWOptions(
+    schema,
+    input,
+    options,
+    formatError
+  );
+  if (error) {
+    if (log) {
+      log.warn(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    } else {
+      (0, import_debug.debugLog)(__spreadValues({ err: error }, import_log.QUERYABLE), "Invalid input");
+    }
+    throw error;
+  }
+  return data;
+};
+var getValidator = (schema, formatError) => {
+  return {
+    validateInput: (input, log) => hardValidate(schema, input, log, formatError),
+    validateInputWOptions: (input, options, log) => hardValidateWOptions(schema, input, options, log, formatError),
+    softValidateInput: (input) => softValidate(schema, input, formatError),
+    softValidateWOptions: (input, options) => softValidateWOptions(schema, input, options, formatError)
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getValidator,
+  getValidatorError,
+  hardValidate,
+  hardValidateWOptions,
+  softValidate,
+  softValidateWOptions
+});