@uipath/uipath-typescript 1.1.3 → 1.2.1

package/dist/index.umd.js

@@ -278,6 +278,11 @@
     }
     function pick(schema, mask) {
         const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".pick() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const newShape = {};
@@ -298,6 +303,11 @@
     }
     function omit(schema, mask) {
         const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".omit() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const newShape = { ...schema._zod.def.shape };
@@ -323,7 +333,14 @@
         const checks = schema._zod.def.checks;
         const hasChecks = checks && checks.length > 0;
         if (hasChecks) {
-            throw new Error("Object schemas containing refinements cannot be extended. Use `.safeExtend()` instead.");
+            // Only throw if new shape overlaps with existing shape
+            // Use getOwnPropertyDescriptor to check key existence without accessing values
+            const existingShape = schema._zod.def.shape;
+            for (const key in shape) {
+                if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+                    throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+                }
+            }
         }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
@@ -331,7 +348,6 @@
                 assignProp(this, "shape", _shape); // self-caching
                 return _shape;
             },
-            checks: [],
         });
         return clone(schema, def);
     }
@@ -339,15 +355,13 @@
         if (!isPlainObject$1(shape)) {
             throw new Error("Invalid input to safeExtend: expected a plain object");
         }
-        const def = {
-            ...schema._zod.def,
+        const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const _shape = { ...schema._zod.def.shape, ...shape };
                 assignProp(this, "shape", _shape); // self-caching
                 return _shape;
             },
-            checks: schema._zod.def.checks,
-        };
+        });
         return clone(schema, def);
     }
     function merge$1(a, b) {
@@ -365,6 +379,12 @@
         return clone(a, def);
     }
     function partial(Class, schema, mask) {
+        const currDef = schema._zod.def;
+        const checks = currDef.checks;
+        const hasChecks = checks && checks.length > 0;
+        if (hasChecks) {
+            throw new Error(".partial() cannot be used on object schemas containing refinements");
+        }
         const def = mergeDefs(schema._zod.def, {
             get shape() {
                 const oldShape = schema._zod.def.shape;
@@ -434,7 +454,6 @@
                 assignProp(this, "shape", shape); // self-caching
                 return shape;
             },
-            checks: [],
         });
         return clone(schema, def);
     }
@@ -684,7 +703,8 @@
     const base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
     const base64url = /^[A-Za-z0-9_-]*$/;
     // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
-    const e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
+    // E.164: leading digit must be 1-9; total digits (excluding '+') between 7-15
+    const e164 = /^\+[1-9]\d{6,14}$/;
     // const dateSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
     const dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
     const date$1 = /*@__PURE__*/ new RegExp(`^${dateSource}$`);
@@ -988,8 +1008,8 @@
 
     const version = {
         major: 4,
-        minor: 2,
-        patch: 1,
+        minor: 3,
+        patch: 6,
     };
 
     const $ZodType = /*@__PURE__*/ $constructor("$ZodType", (inst, def) => {
@@ -1099,7 +1119,8 @@
                 return runChecks(result, checks, ctx);
             };
         }
-        inst["~standard"] = {
+        // Lazy initialize ~standard to avoid creating objects for every schema
+        defineLazy(inst, "~standard", () => ({
             validate: (value) => {
                 try {
                     const r = safeParse$1(inst, value);
@@ -1111,7 +1132,7 @@
             },
             vendor: "zod",
             version: 1,
-        };
+        }));
     });
     const $ZodString = /*@__PURE__*/ $constructor("$ZodString", (inst, def) => {
         $ZodType.init(inst, def);
@@ -1481,8 +1502,12 @@
             return payload; //handleArrayResultsAsync(parseResults, final);
         };
     });
-    function handlePropertyResult(result, final, key, input) {
+    function handlePropertyResult(result, final, key, input, isOptionalOut) {
         if (result.issues.length) {
+            // For optional-out schemas, ignore errors on absent keys
+            if (isOptionalOut && !(key in input)) {
+                return;
+            }
             final.issues.push(...prefixIssues(key, result.issues));
         }
         if (result.value === undefined) {
@@ -1516,6 +1541,7 @@
         const keySet = def.keySet;
         const _catchall = def.catchall._zod;
         const t = _catchall.def.type;
+        const isOptionalOut = _catchall.optout === "optional";
         for (const key in input) {
             if (keySet.has(key))
                 continue;
@@ -1525,10 +1551,10 @@
             }
             const r = _catchall.run({ value: input[key], issues: [] }, ctx);
             if (r instanceof Promise) {
-                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+                proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
             }
             else {
-                handlePropertyResult(r, payload, key, input);
+                handlePropertyResult(r, payload, key, input, isOptionalOut);
             }
         }
         if (unrecognized.length) {
@@ -1596,12 +1622,13 @@
             const shape = value.shape;
             for (const key of value.keys) {
                 const el = shape[key];
+                const isOptionalOut = el._zod.optout === "optional";
                 const r = el._zod.run({ value: input[key], issues: [] }, ctx);
                 if (r instanceof Promise) {
-                    proms.push(r.then((r) => handlePropertyResult(r, payload, key, input)));
+                    proms.push(r.then((r) => handlePropertyResult(r, payload, key, input, isOptionalOut)));
                 }
                 else {
-                    handlePropertyResult(r, payload, key, input);
+                    handlePropertyResult(r, payload, key, input, isOptionalOut);
                 }
             }
             if (!catchall) {
@@ -1633,8 +1660,33 @@
             for (const key of normalized.keys) {
                 const id = ids[key];
                 const k = esc(key);
+                const schema = shape[key];
+                const isOptionalOut = schema?._zod?.optout === "optional";
                 doc.write(`const ${id} = ${parseStr(key)};`);
-                doc.write(`
+                if (isOptionalOut) {
+                    // For optional-out schemas, ignore errors on absent keys
+                    doc.write(`
+        if (${id}.issues.length) {
+          if (${k} in input) {
+            payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
+              ...iss,
+              path: iss.path ? [${k}, ...iss.path] : [${k}]
+            })));
+          }
+        }
+        
+        if (${id}.value === undefined) {
+          if (${k} in input) {
+            newResult[${k}] = undefined;
+          }
+        } else {
+          newResult[${k}] = ${id}.value;
+        }
+        
+      `);
+                }
+                else {
+                    doc.write(`
         if (${id}.issues.length) {
           payload.issues = payload.issues.concat(${id}.issues.map(iss => ({
             ...iss,
@@ -1642,7 +1694,6 @@
           })));
         }
         
-        
         if (${id}.value === undefined) {
           if (${k} in input) {
             newResult[${k}] = undefined;
@@ -1652,6 +1703,7 @@
         }
         
       `);
+                }
             }
             doc.write(`payload.value = newResult;`);
             doc.write(`return payload;`);
@@ -1818,11 +1870,38 @@
         return { valid: false, mergeErrorPath: [] };
     }
     function handleIntersectionResults(result, left, right) {
-        if (left.issues.length) {
-            result.issues.push(...left.issues);
+        // Track which side(s) report each key as unrecognized
+        const unrecKeys = new Map();
+        let unrecIssue;
+        for (const iss of left.issues) {
+            if (iss.code === "unrecognized_keys") {
+                unrecIssue ?? (unrecIssue = iss);
+                for (const k of iss.keys) {
+                    if (!unrecKeys.has(k))
+                        unrecKeys.set(k, {});
+                    unrecKeys.get(k).l = true;
+                }
+            }
+            else {
+                result.issues.push(iss);
+            }
+        }
+        for (const iss of right.issues) {
+            if (iss.code === "unrecognized_keys") {
+                for (const k of iss.keys) {
+                    if (!unrecKeys.has(k))
+                        unrecKeys.set(k, {});
+                    unrecKeys.get(k).r = true;
+                }
+            }
+            else {
+                result.issues.push(iss);
+            }
         }
-        if (right.issues.length) {
-            result.issues.push(...right.issues);
+        // Report only keys unrecognized by BOTH sides
+        const bothKeys = [...unrecKeys].filter(([, f]) => f.l && f.r).map(([k]) => k);
+        if (bothKeys.length && unrecIssue) {
+            result.issues.push({ ...unrecIssue, keys: bothKeys });
         }
         if (aborted(result))
             return result;
@@ -1907,6 +1986,17 @@
             return def.innerType._zod.run(payload, ctx);
         };
     });
+    const $ZodExactOptional = /*@__PURE__*/ $constructor("$ZodExactOptional", (inst, def) => {
+        // Call parent init - inherits optin/optout = "optional"
+        $ZodOptional.init(inst, def);
+        // Override values/pattern to NOT add undefined
+        defineLazy(inst._zod, "values", () => def.innerType._zod.values);
+        defineLazy(inst._zod, "pattern", () => def.innerType._zod.pattern);
+        // Override parse to just delegate (no undefined handling)
+        inst._zod.parse = (payload, ctx) => {
+            return def.innerType._zod.run(payload, ctx);
+        };
+    });
     const $ZodNullable = /*@__PURE__*/ $constructor("$ZodNullable", (inst, def) => {
         $ZodType.init(inst, def);
         defineLazy(inst._zod, "optin", () => def.innerType._zod.optin);
@@ -2129,9 +2219,6 @@
             const meta = _meta[0];
             this._map.set(schema, meta);
             if (meta && typeof meta === "object" && "id" in meta) {
-                if (this._idmap.has(meta.id)) {
-                    throw new Error(`ID ${meta.id} already exists in the registry`);
-                }
                 this._idmap.set(meta.id, schema);
             }
             return this;
@@ -2172,12 +2259,14 @@
     (_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry());
     const globalRegistry = globalThis.__zod_globalRegistry;
 
+    // @__NO_SIDE_EFFECTS__
     function _string(Class, params) {
         return new Class({
             type: "string",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _email(Class, params) {
         return new Class({
             type: "string",
@@ -2187,6 +2276,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _guid(Class, params) {
         return new Class({
             type: "string",
@@ -2196,6 +2286,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuid(Class, params) {
         return new Class({
             type: "string",
@@ -2205,6 +2296,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv4(Class, params) {
         return new Class({
             type: "string",
@@ -2215,6 +2307,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv6(Class, params) {
         return new Class({
             type: "string",
@@ -2225,6 +2318,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uuidv7(Class, params) {
         return new Class({
             type: "string",
@@ -2235,6 +2329,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _url(Class, params) {
         return new Class({
             type: "string",
@@ -2244,6 +2339,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _emoji(Class, params) {
         return new Class({
             type: "string",
@@ -2253,6 +2349,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _nanoid(Class, params) {
         return new Class({
             type: "string",
@@ -2262,6 +2359,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cuid(Class, params) {
         return new Class({
             type: "string",
@@ -2271,6 +2369,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cuid2(Class, params) {
         return new Class({
             type: "string",
@@ -2280,6 +2379,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ulid(Class, params) {
         return new Class({
             type: "string",
@@ -2289,6 +2389,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _xid(Class, params) {
         return new Class({
             type: "string",
@@ -2298,6 +2399,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ksuid(Class, params) {
         return new Class({
             type: "string",
@@ -2307,6 +2409,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ipv4(Class, params) {
         return new Class({
             type: "string",
@@ -2316,6 +2419,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _ipv6(Class, params) {
         return new Class({
             type: "string",
@@ -2325,6 +2429,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cidrv4(Class, params) {
         return new Class({
             type: "string",
@@ -2334,6 +2439,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _cidrv6(Class, params) {
         return new Class({
             type: "string",
@@ -2343,6 +2449,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _base64(Class, params) {
         return new Class({
             type: "string",
@@ -2352,6 +2459,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _base64url(Class, params) {
         return new Class({
             type: "string",
@@ -2361,6 +2469,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _e164(Class, params) {
         return new Class({
             type: "string",
@@ -2370,6 +2479,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _jwt(Class, params) {
         return new Class({
             type: "string",
@@ -2379,6 +2489,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDateTime(Class, params) {
         return new Class({
             type: "string",
@@ -2390,6 +2501,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDate(Class, params) {
         return new Class({
             type: "string",
@@ -2398,6 +2510,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoTime(Class, params) {
         return new Class({
             type: "string",
@@ -2407,6 +2520,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _isoDuration(Class, params) {
         return new Class({
             type: "string",
@@ -2415,17 +2529,20 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _unknown(Class) {
         return new Class({
             type: "unknown",
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _never(Class, params) {
         return new Class({
             type: "never",
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _maxLength(maximum, params) {
         const ch = new $ZodCheckMaxLength({
             check: "max_length",
@@ -2434,6 +2551,7 @@
         });
         return ch;
     }
+    // @__NO_SIDE_EFFECTS__
     function _minLength(minimum, params) {
         return new $ZodCheckMinLength({
             check: "min_length",
@@ -2441,6 +2559,7 @@
             minimum,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _length(length, params) {
         return new $ZodCheckLengthEquals({
             check: "length_equals",
@@ -2448,6 +2567,7 @@
             length,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _regex(pattern, params) {
         return new $ZodCheckRegex({
             check: "string_format",
@@ -2456,6 +2576,7 @@
             pattern,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _lowercase(params) {
         return new $ZodCheckLowerCase({
             check: "string_format",
@@ -2463,6 +2584,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _uppercase(params) {
         return new $ZodCheckUpperCase({
             check: "string_format",
@@ -2470,6 +2592,7 @@
             ...normalizeParams(params),
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _includes(includes, params) {
         return new $ZodCheckIncludes({
             check: "string_format",
@@ -2478,6 +2601,7 @@
             includes,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _startsWith(prefix, params) {
         return new $ZodCheckStartsWith({
             check: "string_format",
@@ -2486,6 +2610,7 @@
             prefix,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _endsWith(suffix, params) {
         return new $ZodCheckEndsWith({
             check: "string_format",
@@ -2494,6 +2619,7 @@
             suffix,
         });
     }
+    // @__NO_SIDE_EFFECTS__
     function _overwrite(tx) {
         return new $ZodCheckOverwrite({
             check: "overwrite",
@@ -2501,25 +2627,31 @@
         });
     }
     // normalize
+    // @__NO_SIDE_EFFECTS__
     function _normalize(form) {
         return _overwrite((input) => input.normalize(form));
     }
     // trim
+    // @__NO_SIDE_EFFECTS__
     function _trim() {
         return _overwrite((input) => input.trim());
     }
     // toLowerCase
+    // @__NO_SIDE_EFFECTS__
     function _toLowerCase() {
         return _overwrite((input) => input.toLowerCase());
     }
     // toUpperCase
+    // @__NO_SIDE_EFFECTS__
     function _toUpperCase() {
         return _overwrite((input) => input.toUpperCase());
     }
     // slugify
+    // @__NO_SIDE_EFFECTS__
     function _slugify() {
         return _overwrite((input) => slugify(input));
     }
+    // @__NO_SIDE_EFFECTS__
     function _array(Class, element, params) {
         return new Class({
             type: "array",
@@ -2531,6 +2663,7 @@
         });
     }
     // same as _custom but defaults to abort:false
+    // @__NO_SIDE_EFFECTS__
     function _refine(Class, fn, _params) {
         const schema = new Class({
             type: "custom",
@@ -2540,6 +2673,7 @@
         });
         return schema;
     }
+    // @__NO_SIDE_EFFECTS__
     function _superRefine(fn) {
         const ch = _check((payload) => {
             payload.addIssue = (issue$1) => {
@@ -2562,6 +2696,7 @@
         });
         return ch;
     }
+    // @__NO_SIDE_EFFECTS__
     function _check(fn, params) {
         const ch = new $ZodCheck({
             check: "custom",
@@ -2628,14 +2763,7 @@
                 schemaPath: [..._params.schemaPath, schema],
                 path: _params.path,
             };
-            const parent = schema._zod.parent;
-            if (parent) {
-                // schema was cloned from another schema
-                result.ref = parent;
-                process(parent, ctx, params);
-                ctx.seen.get(parent).isParent = true;
-            }
-            else if (schema._zod.processJSONSchema) {
+            if (schema._zod.processJSONSchema) {
                 schema._zod.processJSONSchema(ctx, result.schema, params);
             }
             else {
@@ -2646,6 +2774,14 @@
                 }
                 processor(schema, ctx, _json, params);
             }
+            const parent = schema._zod.parent;
+            if (parent) {
+                // Also set ref if processor didn't (for inheritance)
+                if (!result.ref)
+                    result.ref = parent;
+                process(parent, ctx, params);
+                ctx.seen.get(parent).isParent = true;
+            }
         }
         // metadata
         const meta = ctx.metadataRegistry.get(schema);
@@ -2671,6 +2807,18 @@
         const root = ctx.seen.get(schema);
         if (!root)
             throw new Error("Unprocessed schema. This is a bug in Zod.");
+        // Track ids to detect duplicates across different schemas
+        const idToSchema = new Map();
+        for (const entry of ctx.seen.entries()) {
+            const id = ctx.metadataRegistry.get(entry[0])?.id;
+            if (id) {
+                const existing = idToSchema.get(id);
+                if (existing && existing !== entry[0]) {
+                    throw new Error(`Duplicate schema id "${id}" detected during JSON Schema conversion. Two different schemas cannot share the same id when converted together.`);
+                }
+                idToSchema.set(id, entry[0]);
+            }
+        }
         // returns a ref to the schema
         // defId will be empty if the ref points to an external schema (or #)
         const makeURI = (entry) => {
@@ -2772,43 +2920,84 @@
         }
     }
     function finalize(ctx, schema) {
-        //
-        // iterate over seen map;
         const root = ctx.seen.get(schema);
         if (!root)
             throw new Error("Unprocessed schema. This is a bug in Zod.");
-        // flatten _refs
+        // flatten refs - inherit properties from parent schemas
         const flattenRef = (zodSchema) => {
             const seen = ctx.seen.get(zodSchema);
+            // already processed
+            if (seen.ref === null)
+                return;
             const schema = seen.def ?? seen.schema;
             const _cached = { ...schema };
-            // already seen
-            if (seen.ref === null) {
-                return;
-            }
-            // flatten ref if defined
             const ref = seen.ref;
-            seen.ref = null; // prevent recursion
+            seen.ref = null; // prevent infinite recursion
             if (ref) {
                 flattenRef(ref);
+                const refSeen = ctx.seen.get(ref);
+                const refSchema = refSeen.schema;
                 // merge referenced schema into current
-                const refSchema = ctx.seen.get(ref).schema;
                 if (refSchema.$ref && (ctx.target === "draft-07" || ctx.target === "draft-04" || ctx.target === "openapi-3.0")) {
+                    // older drafts can't combine $ref with other properties
                     schema.allOf = schema.allOf ?? [];
                     schema.allOf.push(refSchema);
                 }
                 else {
                     Object.assign(schema, refSchema);
-                    Object.assign(schema, _cached); // prevent overwriting any fields in the original schema
+                }
+                // restore child's own properties (child wins)
+                Object.assign(schema, _cached);
+                const isParentRef = zodSchema._zod.parent === ref;
+                // For parent chain, child is a refinement - remove parent-only properties
+                if (isParentRef) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (!(key in _cached)) {
+                            delete schema[key];
+                        }
+                    }
+                }
+                // When ref was extracted to $defs, remove properties that match the definition
+                if (refSchema.$ref && refSeen.def) {
+                    for (const key in schema) {
+                        if (key === "$ref" || key === "allOf")
+                            continue;
+                        if (key in refSeen.def && JSON.stringify(schema[key]) === JSON.stringify(refSeen.def[key])) {
+                            delete schema[key];
+                        }
+                    }
+                }
+            }
+            // If parent was extracted (has $ref), propagate $ref to this schema
+            // This handles cases like: readonly().meta({id}).describe()
+            // where processor sets ref to innerType but parent should be referenced
+            const parent = zodSchema._zod.parent;
+            if (parent && parent !== ref) {
+                // Ensure parent is processed first so its def has inherited properties
+                flattenRef(parent);
+                const parentSeen = ctx.seen.get(parent);
+                if (parentSeen?.schema.$ref) {
+                    schema.$ref = parentSeen.schema.$ref;
+                    // De-duplicate with parent's definition
+                    if (parentSeen.def) {
+                        for (const key in schema) {
+                            if (key === "$ref" || key === "allOf")
+                                continue;
+                            if (key in parentSeen.def && JSON.stringify(schema[key]) === JSON.stringify(parentSeen.def[key])) {
+                                delete schema[key];
+                            }
+                        }
+                    }
                 }
             }
             // execute overrides
-            if (!seen.isParent)
-                ctx.override({
-                    zodSchema: zodSchema,
-                    jsonSchema: schema,
-                    path: seen.path ?? [],
-                });
+            ctx.override({
+                zodSchema: zodSchema,
+                jsonSchema: schema,
+                path: seen.path ?? [],
+            });
         };
         for (const entry of [...ctx.seen.entries()].reverse()) {
             flattenRef(entry[0]);
@@ -2861,8 +3050,8 @@
                 value: {
                     ...schema["~standard"],
                     jsonSchema: {
-                        input: createStandardJSONSchemaMethod(schema, "input"),
-                        output: createStandardJSONSchemaMethod(schema, "output"),
+                        input: createStandardJSONSchemaMethod(schema, "input", ctx.processors),
+                        output: createStandardJSONSchemaMethod(schema, "output", ctx.processors),
                     },
                 },
                 enumerable: false,
@@ -2941,9 +3130,9 @@
         extractDefs(ctx, schema);
         return finalize(ctx, schema);
     };
-    const createStandardJSONSchemaMethod = (schema, io) => (params) => {
+    const createStandardJSONSchemaMethod = (schema, io, processors = {}) => (params) => {
         const { libraryOptions, target } = params ?? {};
-        const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors: {} });
+        const ctx = initializeContext({ ...(libraryOptions ?? {}), target, io, processors });
         process(schema, ctx);
         extractDefs(ctx, schema);
         return finalize(ctx, schema);
@@ -2971,6 +3160,11 @@
             json.format = formatMap[format] ?? format;
             if (json.format === "")
                 delete json.format; // empty format is not valid
+            // JSON Schema format: "time" requires a full time with offset or Z
+            // z.iso.time() does not include timezone information, so format: "time" should never be used
+            if (format === "time") {
+                delete json.format;
+            }
         }
         if (contentEncoding)
             json.contentEncoding = contentEncoding;
@@ -3279,8 +3473,11 @@
                     ...(def.checks ?? []),
                     ...checks.map((ch) => typeof ch === "function" ? { _zod: { check: ch, def: { check: "custom" }, onattach: [] } } : ch),
                 ],
-            }));
+            }), {
+                parent: true,
+            });
         };
+        inst.with = inst.check;
         inst.clone = (def, params) => clone(inst, def, params);
         inst.brand = () => inst;
         inst.register = ((reg, meta) => {
@@ -3308,6 +3505,7 @@
         inst.overwrite = (fn) => inst.check(_overwrite(fn));
         // wrappers
         inst.optional = () => optional(inst);
+        inst.exactOptional = () => exactOptional(inst);
         inst.nullable = () => nullable(inst);
         inst.nullish = () => optional(nullable(inst));
         inst.nonoptional = (params) => nonoptional(inst, params);
@@ -3344,6 +3542,7 @@
         // helpers
         inst.isOptional = () => inst.safeParse(undefined).success;
         inst.isNullable = () => inst.safeParse(null).success;
+        inst.apply = (fn) => fn(inst);
         return inst;
     });
     /** @internal */
@@ -3694,6 +3893,18 @@
             innerType: innerType,
         });
     }
+    const ZodExactOptional = /*@__PURE__*/ $constructor("ZodExactOptional", (inst, def) => {
+        $ZodExactOptional.init(inst, def);
+        ZodType.init(inst, def);
+        inst._zod.processJSONSchema = (ctx, json, params) => optionalProcessor(inst, ctx, json, params);
+        inst.unwrap = () => inst._zod.def.innerType;
+    });
+    function exactOptional(innerType) {
+        return new ZodExactOptional({
+            type: "optional",
+            innerType: innerType,
+        });
+    }
     const ZodNullable = /*@__PURE__*/ $constructor("ZodNullable", (inst, def) => {
         $ZodNullable.init(inst, def);
         ZodType.init(inst, def);
@@ -3833,7 +4044,6 @@
     class ExecutionContext {
         constructor() {
             this.context = new Map();
-            this.headers = {};
         }
         /**
          * Set a context value that will be available throughout the execution
@@ -3848,35 +4058,10 @@
             return this.context.get(key);
         }
         /**
-         * Set custom headers that will be included in all API requests
-         */
-        setHeaders(headers) {
-            this.headers = { ...this.headers, ...headers };
-        }
-        /**
-         * Get all custom headers
-         */
-        getHeaders() {
-            return { ...this.headers };
-        }
-        /**
-         * Clear all context and headers
+         * Clear all context
          */
         clear() {
             this.context.clear();
-            this.headers = {};
-        }
-        /**
-         * Create a request spec for an API call
-         */
-        createRequestSpec(spec = {}) {
-            return {
-                ...spec,
-                headers: {
-                    ...this.getHeaders(),
-                    ...spec.headers
-                }
-            };
         }
     }
 
@@ -4692,10 +4877,12 @@
             GET_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/read/${recordId}`,
             INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert`,
             BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert-batch`,
+            UPDATE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update/${recordId}`,
             UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update-batch`,
             DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
-            DOWNLOAD_ATTACHMENT: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`,
-            UPLOAD_ATTACHMENT: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`,
+            DOWNLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
+            UPLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
+            DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
         },
         CHOICESETS: {
             GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
@@ -8896,7 +9083,7 @@
     // Connection string placeholder that will be replaced during build
     const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
     // SDK Version placeholder 
-    const SDK_VERSION = "1.1.3";
+    const SDK_VERSION = "1.2.1";
     const VERSION = "Version";
     const SERVICE = "Service";
     const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -9427,6 +9614,15 @@
             __classPrivateFieldGet(this, _UiPath_authService, "f")?.logout();
             __classPrivateFieldSet(this, _UiPath_initialized, false, "f");
         }
+        /**
+         * Updates the access token used for API requests.
+         * Use this to inject or refresh a token externally.
+         *
+         * @param tokenInfo - The token information containing the access token, type, expiration, and optional refresh token
+         */
+        updateToken(tokenInfo) {
+            __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
+        }
     };
     _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
         // Validate and normalize the configuration
@@ -9762,11 +9958,8 @@
             return this.tokenManager.getValidToken();
         }
         async getDefaultHeaders() {
-            // Get headers from execution context first
-            const contextHeaders = this.executionContext.getHeaders();
             const token = await this.getValidToken();
             return {
-                ...contextHeaders,
                 'Authorization': `Bearer ${token}`,
                 'Content-Type': CONTENT_TYPES.JSON,
                 ...this.defaultHeaders,
@@ -11063,6 +11256,13 @@
                     throw new Error('Entity ID is undefined');
                 return service.insertRecordsById(entityData.id, data, options);
             },
+            async updateRecord(recordId, data, options) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                if (!recordId)
+                    throw new Error('Record ID is undefined');
+                return service.updateRecordById(entityData.id, recordId, data, options);
+            },
             async updateRecords(data, options) {
                 if (!entityData.id)
                     throw new Error('Entity ID is undefined');
@@ -11086,24 +11286,19 @@
                 return service.getRecordById(entityData.id, recordId, options);
             },
             async downloadAttachment(recordId, fieldName) {
-                if (!entityData.name)
-                    throw new Error('Entity name is undefined');
-                return service.downloadAttachment({
-                    entityName: entityData.name,
-                    recordId,
-                    fieldName
-                });
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.downloadAttachment(entityData.id, recordId, fieldName);
             },
-            async uploadAttachment(recordId, fieldName, file, expansionLevel) {
-                if (!entityData.name)
-                    throw new Error('Entity name is undefined');
-                return service.uploadAttachment({
-                    entityName: entityData.name,
-                    recordId,
-                    fieldName,
-                    file,
-                    expansionLevel
-                });
+            async uploadAttachment(recordId, fieldName, file, options) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.uploadAttachment(entityData.id, recordId, fieldName, file, options);
+            },
+            async deleteAttachment(recordId, fieldName) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.deleteAttachment(entityData.id, recordId, fieldName);
             },
             async insert(data, options) {
                 return this.insertRecord(data, options);
@@ -11476,6 +11671,42 @@
             const camelResponse = pascalToCamelCaseKeys(response.data);
             return camelResponse;
         }
+        /**
+         * Updates a single record in an entity by entity ID
+         *
+         * @param entityId - UUID of the entity
+         * @param recordId - UUID of the record to update
+         * @param data - Key-value pairs of fields to update
+         * @param options - Update options
+         * @returns Promise resolving to the updated record
+         *
+         * @example
+         * ```typescript
+         * import { Entities } from '@uipath/uipath-typescript/entities';
+         *
+         * const entities = new Entities(sdk);
+         *
+         * // Basic usage
+         * const result = await entities.updateRecordById("<entityId>", "<recordId>", { name: "John Updated", age: 31 });
+         *
+         * // With options
+         * const result = await entities.updateRecordById("<entityId>", "<recordId>", { name: "John Updated", age: 31 }, {
+         *   expansionLevel: 1
+         * });
+         * ```
+         */
+        async updateRecordById(entityId, recordId, data, options = {}) {
+            const params = createParams({
+                expansionLevel: options.expansionLevel
+            });
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_RECORD_BY_ID(entityId, recordId), data, {
+                params,
+                ...options
+            });
+            // Convert PascalCase response to camelCase
+            const camelResponse = pascalToCamelCaseKeys(response.data);
+            return camelResponse;
+        }
         /**
          * Updates data in an entity by entity ID
          *
@@ -11585,7 +11816,9 @@
         /**
          * Downloads an attachment from an entity record field
          *
-         * @param options - Options containing entityName, recordId, and fieldName
+         * @param entityId - UUID of the entity
+         * @param recordId - UUID of the record containing the attachment
+         * @param fieldName - Name of the File-type field containing the attachment
          * @returns Promise resolving to Blob containing the file content
          *
          * @example
@@ -11594,16 +11827,20 @@
          *
          * const entities = new Entities(sdk);
          *
+         * // Get the entityId from getAll()
+         * const allEntities = await entities.getAll();
+         * const entityId = allEntities[0].id;
+         *
+         * // Get the recordId from getAllRecords()
+         * const records = await entities.getAllRecords(entityId);
+         * const recordId = records[0].id;
+         *
          * // Download attachment for a specific record and field
-         * const blob = await entities.downloadAttachment({
-         *   entityName: 'Invoice',
-         *   recordId: '<record-uuid>',
-         *   fieldName: 'Documents'
-         * });
+         * const blob = await entities.downloadAttachment(entityId, recordId, 'Documents');
+         * ```
          */
-        async downloadAttachment(options) {
-            const { entityName, recordId, fieldName } = options;
-            const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.DOWNLOAD_ATTACHMENT(entityName, recordId, fieldName), {
+        async downloadAttachment(entityId, recordId, fieldName) {
+            const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.DOWNLOAD_ATTACHMENT(entityId, recordId, fieldName), {
                 responseType: RESPONSE_TYPES.BLOB
             });
             return response.data;
@@ -11611,8 +11848,12 @@
         /**
          * Uploads an attachment to a File-type field of an entity record
          *
-         * @param options - Options containing entityName, recordId, fieldName, file, and optional expansionLevel
-         * @returns Promise resolving to the upload response
+         * @param entityId - UUID of the entity
+         * @param recordId - UUID of the record to upload the attachment to
+         * @param fieldName - Name of the File-type field
+         * @param file - File to upload (Blob, File, or Uint8Array)
+         * @param options - Optional {@link EntityUploadAttachmentOptions} (e.g. expansionLevel)
+         * @returns Promise resolving to {@link EntityUploadAttachmentResponse}
          *
          * @example
          * ```typescript
@@ -11620,17 +11861,19 @@
          *
          * const entities = new Entities(sdk);
          *
+         * // Get the entityId from getAll()
+         * const allEntities = await entities.getAll();
+         * const entityId = allEntities[0].id;
+         *
+         * // Get the recordId from getAllRecords()
+         * const records = await entities.getAllRecords(entityId);
+         * const recordId = records[0].id;
+         *
          * // Upload a file attachment
-         * const response = await entities.uploadAttachment({
-         *   entityName: 'Invoice',
-         *   recordId: '<record-uuid>',
-         *   fieldName: 'Documents',
-         *   file: file
-         * });
+         * const response = await entities.uploadAttachment(entityId, recordId, 'Documents', file);
          * ```
          */
-        async uploadAttachment(options) {
-            const { entityName, recordId, fieldName, file, expansionLevel } = options;
+        async uploadAttachment(entityId, recordId, fieldName, file, options) {
             const formData = new FormData();
             if (file instanceof Uint8Array) {
                 formData.append('file', new Blob([file.buffer]));
@@ -11638,12 +11881,42 @@
             else {
                 formData.append('file', file);
             }
-            const params = createParams({ expansionLevel });
-            const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPLOAD_ATTACHMENT(entityName, recordId, fieldName), formData, { params });
+            const params = createParams({ expansionLevel: options?.expansionLevel });
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPLOAD_ATTACHMENT(entityId, recordId, fieldName), formData, { params });
             // Convert PascalCase response to camelCase
             const camelResponse = pascalToCamelCaseKeys(response.data);
             return camelResponse;
         }
+        /**
+         * Removes an attachment from a File-type field of an entity record
+         *
+         * @param entityId - UUID of the entity
+         * @param recordId - UUID of the record containing the attachment
+         * @param fieldName - Name of the File-type field containing the attachment
+         * @returns Promise resolving to {@link EntityDeleteAttachmentResponse}
+         *
+         * @example
+         * ```typescript
+         * import { Entities } from '@uipath/uipath-typescript/entities';
+         *
+         * const entities = new Entities(sdk);
+         *
+         * // Get the entityId from getAll()
+         * const allEntities = await entities.getAll();
+         * const entityId = allEntities[0].id;
+         *
+         * // Get the recordId from getAllRecords()
+         * const records = await entities.getAllRecords(entityId);
+         * const recordId = records[0].id;
+         *
+         * // Delete attachment for a specific record and field
+         * await entities.deleteAttachment(entityId, recordId, 'Documents');
+         * ```
+         */
+        async deleteAttachment(entityId, recordId, fieldName) {
+            const response = await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_ATTACHMENT(entityId, recordId, fieldName));
+            return response.data;
+        }
         /**
        * @hidden
        * @deprecated Use {@link getAllRecords} instead.
@@ -11765,6 +12038,9 @@
     __decorate([
         track('Entities.InsertRecordsById')
     ], EntityService.prototype, "insertRecordsById", null);
+    __decorate([
+        track('Entities.UpdateRecordById')
+    ], EntityService.prototype, "updateRecordById", null);
     __decorate([
         track('Entities.UpdateRecordsById')
     ], EntityService.prototype, "updateRecordsById", null);
@@ -11780,6 +12056,9 @@
     __decorate([
         track('Entities.UploadAttachment')
     ], EntityService.prototype, "uploadAttachment", null);
+    __decorate([
+        track('Entities.DeleteAttachment')
+    ], EntityService.prototype, "deleteAttachment", null);
 
     class ChoiceSetService extends BaseService {
         /**