@utilix-tech/sdk 0.78.0 → 0.80.0

package/dist/index.cjs

@@ -43,13 +43,16 @@ var __export = (target, all) => {
 var json_exports = {};
 __export(json_exports, {
   applyJsonMergePatch: () => applyJsonMergePatch,
+  applyJsonPatch: () => applyJsonPatch,
   csvToJson: () => csvToJson,
   detectFormat: () => detectFormat,
   diffJson: () => diffJson,
+  diffJsonPatch: () => diffJsonPatch,
   evaluateJsonPath: () => evaluateJsonPath,
   formatDiffLine: () => formatDiffLine,
   formatJson: () => formatJson,
   generateExample: () => generateExample,
+  generateJsonPatch: () => generateJsonPatch,
   getJsonStats: () => getJsonStats,
   inferGoType: () => inferGoType,
   inferPythonType: () => inferPythonType,
@@ -1473,6 +1476,219 @@ function applyJsonMergePatch(targetJson, patchJson) {
   }
   return { result: mergeJsonPatch(target, patch) };
 }
+function _escapeJsonPointerToken(token) {
+  return token.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function _unescapeJsonPointerToken(token) {
+  return token.replace(/~1/g, "/").replace(/~0/g, "~");
+}
+function _parseJsonPointer(pointer) {
+  if (pointer === "") return [];
+  if (!pointer.startsWith("/")) throw new Error(`Invalid JSON Pointer "${pointer}": must start with "/"`);
+  return pointer.slice(1).split("/").map(_unescapeJsonPointerToken);
+}
+function _isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _deepEqual(a, b) {
+  if (a === b) return true;
+  if (typeof a !== typeof b) return false;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((v, i) => _deepEqual(v, b[i]));
+  }
+  if (_isPlainObject(a) && _isPlainObject(b)) {
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) return false;
+    return aKeys.every((k) => k in b && _deepEqual(a[k], b[k]));
+  }
+  return false;
+}
+function _getByTokens(doc, tokens) {
+  let current = doc;
+  for (const token of tokens) {
+    if (Array.isArray(current)) {
+      const index = token === "-" ? current.length - 1 : parseInt(token, 10);
+      if (!Number.isInteger(index) || index < 0 || index >= current.length) return { found: false, value: void 0 };
+      current = current[index];
+    } else if (_isPlainObject(current)) {
+      if (!(token in current)) return { found: false, value: void 0 };
+      current = current[token];
+    } else {
+      return { found: false, value: void 0 };
+    }
+  }
+  return { found: true, value: current };
+}
+function diffJsonPatch(a, b) {
+  const ops = [];
+  _diffValue(a, b, "", ops);
+  return ops;
+}
+function _diffValue(a, b, path, ops) {
+  if (_deepEqual(a, b)) return;
+  if (_isPlainObject(a) && _isPlainObject(b)) {
+    for (const key of Object.keys(a)) {
+      if (!(key in b)) ops.push({ op: "remove", path: `${path}/${_escapeJsonPointerToken(key)}` });
+    }
+    for (const key of Object.keys(b)) {
+      const childPath = `${path}/${_escapeJsonPointerToken(key)}`;
+      if (!(key in a)) {
+        ops.push({ op: "add", path: childPath, value: b[key] });
+      } else {
+        _diffValue(a[key], b[key], childPath, ops);
+      }
+    }
+    return;
+  }
+  if (Array.isArray(a) && Array.isArray(b)) {
+    const minLen = Math.min(a.length, b.length);
+    for (let i = 0; i < minLen; i++) {
+      _diffValue(a[i], b[i], `${path}/${i}`, ops);
+    }
+    if (b.length > a.length) {
+      for (let i = a.length; i < b.length; i++) ops.push({ op: "add", path: `${path}/${i}`, value: b[i] });
+    } else if (a.length > b.length) {
+      for (let i = a.length - 1; i >= b.length; i--) ops.push({ op: "remove", path: `${path}/${i}` });
+    }
+    return;
+  }
+  ops.push({ op: "replace", path, value: b });
+}
+function applyJsonPatch(target, operations) {
+  let doc = JSON.parse(JSON.stringify(target ?? null));
+  const applyOne = (op, index) => {
+    if (op.path === void 0 || op.op === void 0) return `Operation ${index}: missing "op" or "path"`;
+    let tokens;
+    try {
+      tokens = _parseJsonPointer(op.path);
+    } catch (e) {
+      return `Operation ${index}: ${e.message}`;
+    }
+    const setAt = (tgtTokens, value) => {
+      if (tgtTokens.length === 0) {
+        doc = value;
+        return null;
+      }
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _getByTokens(doc, parentTokens);
+      if (!found) return `Operation ${index}: path "${op.path}" has no parent`;
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx > parent.length) return `Operation ${index}: array index "${lastToken}" out of bounds`;
+        parent.splice(idx, 0, value);
+      } else if (_isPlainObject(parent)) {
+        parent[lastToken] = value;
+      } else {
+        return `Operation ${index}: cannot add into a non-object, non-array value at "${op.path}"`;
+      }
+      return null;
+    };
+    const replaceAt = (tgtTokens, value) => {
+      if (tgtTokens.length === 0) {
+        doc = value;
+        return null;
+      }
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _getByTokens(doc, parentTokens);
+      if (!found) return `Operation ${index}: path "${op.path}" has no parent`;
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length - 1 : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= parent.length) return `Operation ${index}: array index "${lastToken}" out of bounds`;
+        parent[idx] = value;
+      } else if (_isPlainObject(parent)) {
+        if (!(lastToken in parent)) return `Operation ${index}: path "${op.path}" does not exist`;
+        parent[lastToken] = value;
+      } else {
+        return `Operation ${index}: cannot replace into a non-object, non-array value at "${op.path}"`;
+      }
+      return null;
+    };
+    const removeAt = (tgtTokens) => {
+      if (tgtTokens.length === 0) return { error: `Operation ${index}: cannot remove the whole document (path "")` };
+      const parentTokens = tgtTokens.slice(0, -1);
+      const lastToken = tgtTokens[tgtTokens.length - 1];
+      const { found, value: parent } = _getByTokens(doc, parentTokens);
+      if (!found) return { error: `Operation ${index}: path "${op.path}" has no parent` };
+      if (Array.isArray(parent)) {
+        const idx = lastToken === "-" ? parent.length - 1 : parseInt(lastToken, 10);
+        if (!Number.isInteger(idx) || idx < 0 || idx >= parent.length) return { error: `Operation ${index}: array index "${lastToken}" out of bounds` };
+        const [removed] = parent.splice(idx, 1);
+        return { error: null, removed };
+      }
+      if (_isPlainObject(parent)) {
+        if (!(lastToken in parent)) return { error: `Operation ${index}: path "${op.path}" does not exist` };
+        const removed = parent[lastToken];
+        delete parent[lastToken];
+        return { error: null, removed };
+      }
+      return { error: `Operation ${index}: cannot remove from a non-object, non-array value at "${op.path}"` };
+    };
+    switch (op.op) {
+      case "add":
+        return setAt(tokens, op.value);
+      case "replace":
+        return replaceAt(tokens, op.value);
+      case "remove":
+        return removeAt(tokens).error;
+      case "test": {
+        const { found, value } = _getByTokens(doc, tokens);
+        if (!found) return `Operation ${index}: path "${op.path}" does not exist`;
+        if (!_deepEqual(value, op.value)) return `Operation ${index}: test failed at "${op.path}"`;
+        return null;
+      }
+      case "move": {
+        if (!op.from) return `Operation ${index}: "move" requires "from"`;
+        let fromTokens;
+        try {
+          fromTokens = _parseJsonPointer(op.from);
+        } catch (e) {
+          return `Operation ${index}: ${e.message}`;
+        }
+        const removal = removeAt(fromTokens);
+        if (removal.error) return removal.error;
+        return setAt(tokens, removal.removed);
+      }
+      case "copy": {
+        if (!op.from) return `Operation ${index}: "copy" requires "from"`;
+        let fromTokens;
+        try {
+          fromTokens = _parseJsonPointer(op.from);
+        } catch (e) {
+          return `Operation ${index}: ${e.message}`;
+        }
+        const { found, value } = _getByTokens(doc, fromTokens);
+        if (!found) return `Operation ${index}: "from" path "${op.from}" does not exist`;
+        return setAt(tokens, JSON.parse(JSON.stringify(value)));
+      }
+      default:
+        return `Operation ${index}: unknown op "${op.op}"`;
+    }
+  };
+  for (let i = 0; i < operations.length; i++) {
+    const err = applyOne(operations[i], i);
+    if (err) return { error: err };
+  }
+  return { result: doc };
+}
+function generateJsonPatch(aJson, bJson) {
+  let a;
+  try {
+    a = JSON.parse(aJson);
+  } catch {
+    return { error: "First document is not valid JSON" };
+  }
+  let b;
+  try {
+    b = JSON.parse(bJson);
+  } catch {
+    return { error: "Second document is not valid JSON" };
+  }
+  return { patch: diffJsonPatch(a, b) };
+}
 
 // src/tools/encoding.ts
 var encoding_exports = {};
@@ -8706,6 +8922,7 @@ __export(units_exports, {
   calculateMovingAverages: () => calculateMovingAverages,
   calculatePaybackPeriod: () => calculatePaybackPeriod,
   calculatePercentageChange: () => calculatePercentageChange,
+  calculateRealRateOfReturn: () => calculateRealRateOfReturn,
   calculateRequiredBandwidth: () => calculateRequiredBandwidth,
   calculateRoi: () => calculateRoi,
   calculateRuleOf72: () => calculateRuleOf72,
@@ -11424,6 +11641,50 @@ function calculateRequiredBandwidth(fileSize, fileSizeUnit, targetSeconds) {
     requiredMBps: requiredBitsPerSecond / 8 / 1e6
   };
 }
+var _REAL_RATE_FIELDS = ["nominalRatePercent", "inflationRatePercent", "realRatePercent"];
+function calculateRealRateOfReturn(input) {
+  const provided = (v) => typeof v === "number" && Number.isFinite(v);
+  const given = _REAL_RATE_FIELDS.filter((f) => provided(input[f]));
+  if (given.length !== 2) {
+    return { error: `Provide exactly two of nominalRatePercent, inflationRatePercent, realRatePercent (got ${given.length})` };
+  }
+  for (const f of given) {
+    const v = input[f];
+    if (v <= -100) return { error: `${f} must be greater than -100` };
+  }
+  const has = (f) => given.includes(f);
+  const nominal0 = input.nominalRatePercent;
+  const inflation0 = input.inflationRatePercent;
+  const real0 = input.realRatePercent;
+  let nominalRatePercent;
+  let inflationRatePercent;
+  let realRatePercent;
+  let solvedFor;
+  if (has("nominalRatePercent") && has("inflationRatePercent")) {
+    nominalRatePercent = nominal0;
+    inflationRatePercent = inflation0;
+    realRatePercent = ((1 + nominal0 / 100) / (1 + inflation0 / 100) - 1) * 100;
+    solvedFor = "realRatePercent";
+  } else if (has("realRatePercent") && has("inflationRatePercent")) {
+    realRatePercent = real0;
+    inflationRatePercent = inflation0;
+    nominalRatePercent = ((1 + real0 / 100) * (1 + inflation0 / 100) - 1) * 100;
+    solvedFor = "nominalRatePercent";
+  } else {
+    nominalRatePercent = nominal0;
+    realRatePercent = real0;
+    inflationRatePercent = ((1 + nominal0 / 100) / (1 + real0 / 100) - 1) * 100;
+    solvedFor = "inflationRatePercent";
+  }
+  const round4 = (n) => Math.round(n * 1e4) / 1e4;
+  return {
+    nominalRatePercent: round4(nominalRatePercent),
+    inflationRatePercent: round4(inflationRatePercent),
+    realRatePercent: round4(realRatePercent),
+    given,
+    solvedFor
+  };
+}
 
 // src/tools/network.ts
 var network_exports = {};
@@ -16512,6 +16773,7 @@ __export(code_exports, {
   minifySql: () => minifySql,
   normalizeRef: () => normalizeRef,
   parseCommitTrailers: () => parseCommitTrailers,
+  parseConnectionString: () => parseConnectionString,
   parseDockerImage: () => parseDockerImage,
   parseEnv: () => parseEnv2,
   parseGitCommand: () => parseGitCommand,
@@ -20344,6 +20606,53 @@ function validateAria(html) {
     valid: issues.every((i) => i.severity !== "error")
   };
 }
+var CONNECTION_STRING_RE = /^([a-zA-Z][a-zA-Z0-9+.-]*):\/\/(?:([^@/?#]*)@)?([^/?#]*)(?:\/([^?#]*))?(?:\?([^#]*))?$/;
+function _parseConnectionHost(segment) {
+  const ipv6Match = segment.match(/^\[([^\]]+)\](?::(\d+))?$/);
+  if (ipv6Match) {
+    return { host: ipv6Match[1], port: ipv6Match[2] ? parseInt(ipv6Match[2], 10) : null };
+  }
+  const lastColon = segment.lastIndexOf(":");
+  if (lastColon === -1) return { host: segment, port: null };
+  const portPart = segment.slice(lastColon + 1);
+  if (!/^\d+$/.test(portPart)) return { host: segment, port: null };
+  return { host: segment.slice(0, lastColon), port: parseInt(portPart, 10) };
+}
+function parseConnectionString(input) {
+  if (!input || typeof input !== "string" || !input.trim()) {
+    return { error: "Connection string is empty" };
+  }
+  const trimmed = input.trim();
+  const match = trimmed.match(CONNECTION_STRING_RE);
+  if (!match) {
+    return { error: "Not a valid scheme://[user[:password]@]host[,host2][/database][?params] connection string" };
+  }
+  const [, scheme, userinfo, hostPart, databasePart, queryPart] = match;
+  let user = null;
+  let password = null;
+  if (userinfo) {
+    const sepIndex = userinfo.indexOf(":");
+    if (sepIndex === -1) {
+      user = decodeURIComponent(userinfo);
+    } else {
+      user = decodeURIComponent(userinfo.slice(0, sepIndex));
+      password = decodeURIComponent(userinfo.slice(sepIndex + 1));
+    }
+  }
+  const hosts = hostPart ? hostPart.split(",").filter(Boolean).map(_parseConnectionHost) : [];
+  const database = databasePart ? decodeURIComponent(databasePart) : null;
+  const params = {};
+  if (queryPart) {
+    for (const pair of queryPart.split("&")) {
+      if (!pair) continue;
+      const eqIndex = pair.indexOf("=");
+      const key = eqIndex === -1 ? pair : pair.slice(0, eqIndex);
+      const value = eqIndex === -1 ? "" : pair.slice(eqIndex + 1);
+      params[decodeURIComponent(key)] = decodeURIComponent(value);
+    }
+  }
+  return { scheme, user, password, hosts, database, params };
+}
 
 // src/tools/color.ts
 var color_exports = {};
@@ -23928,6 +24237,7 @@ function generateMetaHtml2(tags) {
 var ai_agent_exports = {};
 __export(ai_agent_exports, {
   MODEL_PRICING: () => MODEL_PRICING,
+  calculateRetryBackoffSchedule: () => calculateRetryBackoffSchedule,
   chunkText: () => chunkText,
   compressHtml: () => compressHtml,
   compressJson: () => compressJson,
@@ -25040,6 +25350,62 @@ function lintToolSchema(jsonText) {
   const valid = !issues.some((i) => i.severity === "error");
   return { toolCount: normalized.length, issues, valid };
 }
+function calculateRetryBackoffSchedule(input) {
+  const { baseDelayMs, multiplier, maxRetries, maxDelayMs, jitter = "none" } = input;
+  if (!Number.isFinite(baseDelayMs) || baseDelayMs <= 0) {
+    return { error: "baseDelayMs must be a finite number greater than zero" };
+  }
+  if (!Number.isFinite(multiplier) || multiplier < 1) {
+    return { error: "multiplier must be a finite number of at least 1" };
+  }
+  if (!Number.isInteger(maxRetries) || maxRetries < 1 || maxRetries > 50) {
+    return { error: "maxRetries must be a whole number between 1 and 50" };
+  }
+  if (maxDelayMs !== void 0 && maxDelayMs !== null) {
+    if (!Number.isFinite(maxDelayMs) || maxDelayMs <= 0) {
+      return { error: "maxDelayMs must be a finite number greater than zero when provided" };
+    }
+  }
+  if (jitter !== "none" && jitter !== "full" && jitter !== "equal") {
+    return { error: "jitter must be one of 'none', 'full', or 'equal'" };
+  }
+  const round0 = (n) => Math.round(n);
+  const attempts = [];
+  let totalBestCaseMs = 0;
+  let totalWorstCaseMs = 0;
+  for (let i = 1; i <= maxRetries; i++) {
+    let nominal = baseDelayMs * Math.pow(multiplier, i - 1);
+    if (maxDelayMs !== void 0 && maxDelayMs !== null) {
+      nominal = Math.min(nominal, maxDelayMs);
+    }
+    let minDelay;
+    let maxDelay;
+    if (jitter === "full") {
+      minDelay = 0;
+      maxDelay = nominal;
+    } else if (jitter === "equal") {
+      minDelay = nominal / 2;
+      maxDelay = nominal;
+    } else {
+      minDelay = nominal;
+      maxDelay = nominal;
+    }
+    attempts.push({
+      attempt: i,
+      nominalDelayMs: round0(nominal),
+      minDelayMs: round0(minDelay),
+      maxDelayMs: round0(maxDelay)
+    });
+    totalBestCaseMs += minDelay;
+    totalWorstCaseMs += maxDelay;
+  }
+  return {
+    attempts,
+    jitter,
+    totalBestCaseMs: round0(totalBestCaseMs),
+    totalWorstCaseMs: round0(totalWorstCaseMs)
+  };
+}
 
 // src/tools/media.ts
 var media_exports = {};

package/dist/index.d.cts

@@ -1,18 +1,18 @@
-export { j as json } from './json-CaiYsGDQ.cjs';
+export { j as json } from './json-Ca6gZCNB.cjs';
 export { e as encoding } from './encoding-Dk3wpmb3.cjs';
 export { h as hashing } from './hashing-CJjlvqS_.cjs';
 export { t as text } from './text-CNn3whZA.cjs';
 export { d as data } from './data-DIyBrJ6l.cjs';
 export { g as generators } from './generators-DAXXrMvG.cjs';
 export { t as time } from './time-KqJjdqII.cjs';
-export { u as units } from './units-BqegyALA.cjs';
+export { u as units } from './units-D7YRRwei.cjs';
 export { n as network } from './network-BskZe1n2.cjs';
 export { a as api } from './api-CQnIUrVB.cjs';
-export { c as code } from './code-46xO9xFf.cjs';
+export { c as code } from './code-C4n621_i.cjs';
 export { c as color } from './color-tPwZCr9H.cjs';
 export { c as css } from './css-Cf7AMGM-.cjs';
 export { m as misc } from './misc-CA3N198T.cjs';
-export { a as ai_agent } from './ai_agent-CmrVjvYH.cjs';
+export { a as ai_agent } from './ai_agent-DeCy0oZK.cjs';
 export { m as media } from './media-DF8BS-iA.cjs';
 
 declare const version = "0.1.0";

package/dist/index.d.ts

@@ -1,18 +1,18 @@
-export { j as json } from './json-CaiYsGDQ.js';
+export { j as json } from './json-Ca6gZCNB.js';
 export { e as encoding } from './encoding-Dk3wpmb3.js';
 export { h as hashing } from './hashing-CJjlvqS_.js';
 export { t as text } from './text-CNn3whZA.js';
 export { d as data } from './data-DIyBrJ6l.js';
 export { g as generators } from './generators-DAXXrMvG.js';
 export { t as time } from './time-KqJjdqII.js';
-export { u as units } from './units-BqegyALA.js';
+export { u as units } from './units-D7YRRwei.js';
 export { n as network } from './network-BskZe1n2.js';
 export { a as api } from './api-CQnIUrVB.js';
-export { c as code } from './code-46xO9xFf.js';
+export { c as code } from './code-C4n621_i.js';
 export { c as color } from './color-tPwZCr9H.js';
 export { c as css } from './css-Cf7AMGM-.js';
 export { m as misc } from './misc-CA3N198T.js';
-export { a as ai_agent } from './ai_agent-CmrVjvYH.js';
+export { a as ai_agent } from './ai_agent-DeCy0oZK.js';
 export { m as media } from './media-DF8BS-iA.js';
 
 declare const version = "0.1.0";

package/dist/index.js

@@ -1,13 +1,13 @@
 export { media_exports as media } from './chunk-ZWFZRDQ4.js';
-export { units_exports as units } from './chunk-RP574L5Z.js';
+export { units_exports as units } from './chunk-OFLNVDNX.js';
 export { network_exports as network } from './chunk-KWS4ZCYG.js';
 export { api_exports as api } from './chunk-U2HREMZU.js';
-export { code_exports as code } from './chunk-XT2BQWXT.js';
+export { code_exports as code } from './chunk-RYSN5JNA.js';
 export { color_exports as color } from './chunk-BPVAB4P2.js';
 export { css_exports as css } from './chunk-6YPV2AB5.js';
 export { misc_exports as misc } from './chunk-GX7H6TAX.js';
-export { ai_agent_exports as ai_agent } from './chunk-EKIXOA7B.js';
-export { json_exports as json } from './chunk-34C6GXCC.js';
+export { ai_agent_exports as ai_agent } from './chunk-HJLGUNSO.js';
+export { json_exports as json } from './chunk-WUOZHCIC.js';
 export { encoding_exports as encoding } from './chunk-DOWQZUTP.js';
 export { hashing_exports as hashing } from './chunk-PET2CGTH.js';
 export { text_exports as text } from './chunk-QVOK3BXM.js';

package/dist/{json-CaiYsGDQ.d.cts → json-Ca6gZCNB.d.cts}

@@ -15,6 +15,7 @@
  *   - json-to-zod      : jsonToZod
  *   - json-schema-to-typescript : jsonSchemaToTypescript
  *   - json-merge-patch : mergeJsonPatch, applyJsonMergePatch
+ *   - json-patch       : diffJsonPatch, applyJsonPatch, generateJsonPatch
  */
 type ParseStatus = 'idle' | 'valid' | 'error';
 interface JsonParseResult {
@@ -220,6 +221,43 @@ declare function mergeJsonPatch(target: unknown, patch: unknown): unknown;
 declare function applyJsonMergePatch(targetJson: string, patchJson: string): MergePatchResult | {
     error: string;
 };
+type JsonPatchOp = 'add' | 'remove' | 'replace' | 'move' | 'copy' | 'test';
+interface JsonPatchOperation {
+    op: JsonPatchOp;
+    path: string;
+    value?: unknown;
+    from?: string;
+}
+/**
+ * Generates a minimal (naive, index-by-index for arrays) RFC 6902 JSON
+ * Patch document describing how to transform `a` into `b`. Object keys
+ * produce add/remove/replace; arrays are compared position by position,
+ * with removes emitted from the highest index down and adds appended at
+ * the end, so the resulting patch applies correctly in order. This is not
+ * a minimal-edit-distance diff (it won't detect a reordering as a move) —
+ * just a direct, deterministic structural comparison.
+ */
+declare function diffJsonPatch(a: unknown, b: unknown): JsonPatchOperation[];
+/**
+ * Applies a sequence of RFC 6902 JSON Patch operations to a target
+ * document and returns the result, or an error naming the failing
+ * operation's index. Supports add, remove, replace, move, copy, and test.
+ * The input document is not mutated.
+ */
+declare function applyJsonPatch(target: unknown, operations: JsonPatchOperation[]): {
+    result: unknown;
+} | {
+    error: string;
+};
+/**
+ * Convenience wrapper: diffs two JSON documents given as strings and
+ * returns the generated RFC 6902 patch, or a parse error.
+ */
+declare function generateJsonPatch(aJson: string, bJson: string): {
+    patch: JsonPatchOperation[];
+} | {
+    error: string;
+};
 
 type json_ConvertOptions = ConvertOptions;
 type json_CsvOptions = CsvOptions;
@@ -229,6 +267,8 @@ type json_GoField = GoField;
 type json_GoStruct = GoStruct;
 type json_JsonDiffResult = JsonDiffResult;
 type json_JsonParseResult = JsonParseResult;
+type json_JsonPatchOp = JsonPatchOp;
+type json_JsonPatchOperation = JsonPatchOperation;
 type json_JsonPathResult = JsonPathResult;
 type json_JsonPointerResult = JsonPointerResult;
 type json_JsonSchemaLike = JsonSchemaLike;
@@ -242,13 +282,16 @@ type json_ValidationError = ValidationError;
 type json_ValidationResult = ValidationResult;
 type json_ZodOptions = ZodOptions;
 declare const json_applyJsonMergePatch: typeof applyJsonMergePatch;
+declare const json_applyJsonPatch: typeof applyJsonPatch;
 declare const json_csvToJson: typeof csvToJson;
 declare const json_detectFormat: typeof detectFormat;
 declare const json_diffJson: typeof diffJson;
+declare const json_diffJsonPatch: typeof diffJsonPatch;
 declare const json_evaluateJsonPath: typeof evaluateJsonPath;
 declare const json_formatDiffLine: typeof formatDiffLine;
 declare const json_formatJson: typeof formatJson;
 declare const json_generateExample: typeof generateExample;
+declare const json_generateJsonPatch: typeof generateJsonPatch;
 declare const json_getJsonStats: typeof getJsonStats;
 declare const json_inferGoType: typeof inferGoType;
 declare const json_inferPythonType: typeof inferPythonType;
@@ -272,7 +315,7 @@ declare const json_validateJsonPath: typeof validateJsonPath;
 declare const json_validateJsonString: typeof validateJsonString;
 declare const json_yamlToJson: typeof yamlToJson;
 declare namespace json {
-  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_MergePatchResult as MergePatchResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_applyJsonMergePatch as applyJsonMergePatch, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_mergeJsonPatch as mergeJsonPatch, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
+  export { type json_ConvertOptions as ConvertOptions, type json_CsvOptions as CsvOptions, type json_DiffNode as DiffNode, type json_DiffType as DiffType, type json_GoField as GoField, type json_GoStruct as GoStruct, type json_JsonDiffResult as JsonDiffResult, type json_JsonParseResult as JsonParseResult, type json_JsonPatchOp as JsonPatchOp, type json_JsonPatchOperation as JsonPatchOperation, type json_JsonPathResult as JsonPathResult, type json_JsonPointerResult as JsonPointerResult, type json_JsonSchemaLike as JsonSchemaLike, type json_JsonSchemaToTsOptions as JsonSchemaToTsOptions, type json_MergePatchResult as MergePatchResult, type json_ParseStatus as ParseStatus, type json_PythonClass as PythonClass, type json_PythonField as PythonField, type json_PythonMode as PythonMode, type json_ValidationError as ValidationError, type json_ValidationResult as ValidationResult, type json_ZodOptions as ZodOptions, json_applyJsonMergePatch as applyJsonMergePatch, json_applyJsonPatch as applyJsonPatch, json_csvToJson as csvToJson, json_detectFormat as detectFormat, json_diffJson as diffJson, json_diffJsonPatch as diffJsonPatch, json_evaluateJsonPath as evaluateJsonPath, json_formatDiffLine as formatDiffLine, json_formatJson as formatJson, json_generateExample as generateExample, json_generateJsonPatch as generateJsonPatch, json_getJsonStats as getJsonStats, json_inferGoType as inferGoType, json_inferPythonType as inferPythonType, json_inferType as inferType, json_jsonSchemaToTypescript as jsonSchemaToTypescript, json_jsonToCsv as jsonToCsv, json_jsonToGo as jsonToGo, json_jsonToPython as jsonToPython, json_jsonToTypescript as jsonToTypescript, json_jsonToYaml as jsonToYaml, json_jsonToZod as jsonToZod, json_mergeJsonPatch as mergeJsonPatch, json_minifyJson as minifyJson, json_parseJson as parseJson, json_parseStructs as parseStructs, json_resolveJsonPointer as resolveJsonPointer, json_toPascalCase as toPascalCase, json_toSnakeCase as toSnakeCase, json_validateJson as validateJson, json_validateJsonPath as validateJsonPath, json_validateJsonString as validateJsonString, json_yamlToJson as yamlToJson };
 }
 
-export { jsonToCsv as A, jsonToGo as B, type ConvertOptions as C, type DiffNode as D, jsonToPython as E, jsonToTypescript as F, type GoField as G, jsonToYaml as H, jsonToZod as I, type JsonDiffResult as J, mergeJsonPatch as K, minifyJson as L, type MergePatchResult as M, parseJson as N, parseStructs as O, type ParseStatus as P, resolveJsonPointer as Q, toPascalCase as R, toSnakeCase as S, validateJson as T, validateJsonPath as U, type ValidationError as V, validateJsonString as W, yamlToJson as X, type ZodOptions as Z, type CsvOptions as a, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPathResult as e, type JsonPointerResult as f, type JsonSchemaLike as g, type JsonSchemaToTsOptions as h, type PythonClass as i, json as j, type PythonField as k, type PythonMode as l, type ValidationResult as m, applyJsonMergePatch as n, csvToJson as o, detectFormat as p, diffJson as q, evaluateJsonPath as r, formatDiffLine as s, formatJson as t, generateExample as u, getJsonStats as v, inferGoType as w, inferPythonType as x, inferType as y, jsonSchemaToTypescript as z };
+export { validateJsonPath as $, getJsonStats as A, inferGoType as B, type ConvertOptions as C, type DiffNode as D, inferPythonType as E, inferType as F, type GoField as G, jsonSchemaToTypescript as H, jsonToCsv as I, type JsonDiffResult as J, jsonToGo as K, jsonToPython as L, type MergePatchResult as M, jsonToTypescript as N, jsonToYaml as O, type ParseStatus as P, jsonToZod as Q, mergeJsonPatch as R, minifyJson as S, parseJson as T, parseStructs as U, type ValidationError as V, resolveJsonPointer as W, toPascalCase as X, toSnakeCase as Y, type ZodOptions as Z, validateJson as _, type CsvOptions as a, validateJsonString as a0, yamlToJson as a1, type DiffType as b, type GoStruct as c, type JsonParseResult as d, type JsonPatchOp as e, type JsonPatchOperation as f, type JsonPathResult as g, type JsonPointerResult as h, type JsonSchemaLike as i, json as j, type JsonSchemaToTsOptions as k, type PythonClass as l, type PythonField as m, type PythonMode as n, type ValidationResult as o, applyJsonMergePatch as p, applyJsonPatch as q, csvToJson as r, detectFormat as s, diffJson as t, diffJsonPatch as u, evaluateJsonPath as v, formatDiffLine as w, formatJson as x, generateExample as y, generateJsonPatch as z };