npm - @uipath/data-fabric-tool - Versions diffs - 1.202.0 → 1.203.0-preview.160 - Mend

@uipath/data-fabric-tool 1.202.0 → 1.203.0-preview.160

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (5) hide show

package/dist/THIRD-PARTY-NOTICES.md +31 -1
package/dist/index.js +1 -1
package/dist/{packager-tool-k5a008wm.js → packager-tool-zycs3784.js} +1463 -305
package/dist/tool.js +1 -1
package/package.json +3 -2

package/dist/{packager-tool-k5a008wm.js → packager-tool-zycs3784.js} RENAMED Viewed

@@ -6582,8 +6582,9 @@ var require_src6 = __commonJS(function(exports) {
 // package.json
 var package_default = {
   name: "@uipath/data-fabric-tool",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.203.0-preview.160",
   description: "Manage Data Fabric entities and records.",
   publishConfig: {
     registry: "https://npm.pkg.github.com/"
@@ -6615,7 +6616,7 @@ var package_default = {
     "@uipath/filesystem": "workspace:*",
     "@uipath/packager-tool-datafabric": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
-    "@uipath/uipath-typescript": "^1.6.1",
+    "@uipath/uipath-typescript": "^1.7.1",
     commander: "^14.0.3",
     typescript: "^7.0.2"
   }
@@ -7133,7 +7134,7 @@ var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
 var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
 var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
 var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
@@ -7180,7 +7181,7 @@ var QUOTED_LITERAL_PATTERN = new RegExp([
   `(?<![A-Za-z0-9])"(?:[^\\
 ]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
 ].join("|"), "g");
-var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
 var COLLAPSED_BODY = "{…}";
 var COLLAPSED_BODY_MARKER = "\x01body\x01";
 var MAX_BODY_NESTING = 8;
@@ -7195,10 +7196,13 @@ function collapseJsonBodies(text) {
   }
   return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
 function peelTrailingPunctuation(match) {
-  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
-  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
 }
 function redactUrl(raw) {
   try {
@@ -7501,6 +7505,22 @@ function parseHttpStatusFromMessage(message) {
   const status = Number(match[1]);
   return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
 }
+function findHttpStatusInGraph(error) {
+  for (const node of walkErrorGraph(error)) {
+    const response = node.response;
+    const explicit = typeof node.status === "number" ? node.status : response?.status;
+    if (typeof explicit === "number" && explicit >= 400 && explicit <= 599) {
+      return explicit;
+    }
+    if (typeof node.message === "string") {
+      const parsed = parseHttpStatusFromMessage(node.message);
+      if (parsed !== undefined && parsed >= 400) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
 function isHtmlDocument(body) {
   return /^\s*(<!doctype html|<html\b)/i.test(body);
 }
@@ -7614,7 +7634,8 @@ async function extractErrorDetails(error, options) {
   }
   let message;
   let result = "Failure";
-  const classification = classifyError(status, error);
+  const classificationStatus = status ?? findHttpStatusInGraph(error);
+  const classification = classifyError(classificationStatus, error);
   let retry = classification.retry;
   if (status === 401) {
     message = DEFAULT_401;
@@ -7690,8 +7711,8 @@ async function extractErrorDetails(error, options) {
     details = describeThrownValue(error);
   }
   const context = {};
-  if (status) {
-    context.httpStatus = status;
+  if (classificationStatus) {
+    context.httpStatus = classificationStatus;
   }
   if (parsedBody?.errorCode && typeof parsedBody.errorCode === "string") {
     context.errorCode = parsedBody.errorCode;
@@ -8262,7 +8283,8 @@ function readRegistryValue(keyPath, valueName) {
   }
   const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   }));
   if (error) {
     return "";
@@ -8944,28 +8966,32 @@ function isPlainRecord(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function extractPagedRows(value) {
+function splitPagedEnvelope(value) {
   if (Array.isArray(value) || !isPlainRecord(value))
     return null;
-  const entries = Object.values(value);
+  const entries = Object.entries(value);
   if (entries.length === 0)
     return null;
-  let rows = null;
-  let hasScalarSibling = false;
-  for (const entry of entries) {
+  let found = null;
+  const meta = Object.create(null);
+  for (const [key, entry] of entries) {
     if (Array.isArray(entry)) {
-      if (rows !== null)
+      if (found !== null)
         return null;
-      rows = entry;
+      found = { key, rows: entry };
     } else if (entry !== null && typeof entry === "object") {
       return null;
     } else {
-      hasScalarSibling = true;
+      meta[key] = entry;
     }
   }
-  if (rows === null || !hasScalarSibling)
+  if (found === null || Object.keys(meta).length === 0)
     return null;
-  return rows;
+  return { ...found, meta };
+}
+function extractPagedRows(value) {
+  const paged = splitPagedEnvelope(value);
+  return paged === null ? null : paged.rows;
 }
 function toLowerCamelCaseKey(key) {
   if (!key)
@@ -9069,6 +9095,9 @@ function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowSt
       }
       break;
     }
+    case "markdown":
+      logFn(renderMarkdown(data));
+      break;
     default: {
       const hasData = "Data" in data && data.Data != null;
       const pagedRows = hasData ? extractPagedRows(data.Data) : null;
@@ -9093,6 +9122,10 @@ function logOutput(data, format = "json", tableRowStyle) {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink), styleFn);
 }
+var PLUMBING_KEYS = new Set(["code", "log"]);
+function isPlumbingKey(key) {
+  return PLUMBING_KEYS.has(key.toLowerCase());
+}
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
 }
@@ -9108,7 +9141,7 @@ function wrapText(text, width) {
 function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
   logFn(header);
@@ -9130,7 +9163,7 @@ function isNonEmptyPlainObject(value) {
 }
 var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
-  const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
@@ -9161,7 +9194,7 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
 function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
@@ -9235,6 +9268,220 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
     logFn(`Log: ${externalLogValue}`);
   }
 }
+var MARKDOWN_MAX_CELL = 200;
+var MARKDOWN_MAX_DEPTH = 3;
+function markdownHeading(depth) {
+  return "#".repeat(Math.min(3 + depth, 6));
+}
+var BACKTICK_RUN = /`+/g;
+function fencedBlock(text) {
+  const first = text.trimStart()[0];
+  const language = first === "<" ? "xml" : first === "{" || first === "[" ? "json" : "";
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(BACKTICK_RUN), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  return `${fence}${language}
+${text}
+${fence}`;
+}
+function collapseNewlineRuns(text) {
+  return text.split(/(\s+)/).map((part, index) => index % 2 === 1 && part.includes(`
+`) ? " " : part).join("");
+}
+function markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return collapseNewlineRuns(text).replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return collapseNewlineRuns(key).replace(/[\\`*|]/g, "\\$&");
+}
+function withoutPlumbing(record) {
+  const kept = Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (!isPlumbingKey(key))
+      kept[key] = value;
+  }
+  return kept;
+}
+function rowsWithoutPlumbing(rows) {
+  return rows.map((row) => isPlainRecord(row) ? withoutPlumbing(row) : row);
+}
+function markdownTable(rows) {
+  const columns = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const cells = rows.map((row) => columns.map((key) => markdownCell(row[key])));
+  if (cells.some((row) => row.some((c) => c.length > MARKDOWN_MAX_CELL))) {
+    return null;
+  }
+  return [
+    `| ${columns.map(markdownLabel).join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...cells.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function extractMessageSequence(rows) {
+  const messages = [];
+  for (const row of rows) {
+    const message = extractSingleMessage(row);
+    if (message === null)
+      return null;
+    messages.push(message);
+  }
+  return messages.join(`
+`);
+}
+function markdownRows(rows, depth) {
+  if (rows.length === 0)
+    return "(none)";
+  if (!isPlainObjectArray(rows)) {
+    return rows.map((item) => `- ${markdownCell(item)}`).join(`
+`);
+  }
+  const prose = extractMessageSequence(rows);
+  if (prose !== null)
+    return prose;
+  const table = markdownTable(rows);
+  if (table !== null)
+    return table;
+  if (depth >= MARKDOWN_MAX_DEPTH) {
+    return fencedBlock(JSON.stringify(rows, null, 2));
+  }
+  return rows.map((row, index) => [
+    `${markdownHeading(depth)} ${index + 1}`,
+    markdownObject(row, depth + 1)
+  ].join(`
+`)).join(`
+`);
+}
+function markdownObject(obj, depth) {
+  const scalars = [];
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined)
+      continue;
+    const label = markdownLabel(key);
+    if (Array.isArray(value)) {
+      blocks.push(`${markdownHeading(depth)} ${label}
+${markdownRows(value, depth + 1)}`);
+    } else if (isNonEmptyPlainObject(value)) {
+      const nested = depth < MARKDOWN_MAX_DEPTH ? markdownObject(value, depth + 1) : fencedBlock(JSON.stringify(value, null, 2));
+      if (nested !== "") {
+        blocks.push(`${markdownHeading(depth)} ${label}
+${nested}`);
+      }
+    } else if (typeof value === "string" && value.includes(`
+`)) {
+      blocks.push(`**${label}:**
+${fencedBlock(value)}`);
+    } else {
+      scalars.push(`**${label}:** ${markdownCell(value)}`);
+    }
+  }
+  const sections = scalars.length > 0 ? [scalars.join(`
+`)] : [];
+  sections.push(...blocks);
+  return sections.join(`
+`);
+}
+function extractSingleMessage(payload) {
+  if (!isPlainRecord(payload))
+    return null;
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0].toLowerCase() !== "message")
+    return null;
+  const value = payload[keys[0]];
+  return typeof value === "string" ? value : null;
+}
+function markdownPayload(payload) {
+  const message = extractSingleMessage(payload);
+  if (message !== null)
+    return message;
+  if (Array.isArray(payload)) {
+    return markdownRows(rowsWithoutPlumbing(payload), 0);
+  }
+  const visible = withoutPlumbing(payload);
+  const paged = splitPagedEnvelope(visible);
+  if (paged !== null) {
+    const meta = markdownObject(paged.meta, 0);
+    const rows = `${markdownHeading(0)} ${markdownLabel(paged.key)}
+${markdownRows(rowsWithoutPlumbing(paged.rows), 1)}`;
+    return meta === "" ? rows : `${meta}
+${rows}`;
+  }
+  return markdownObject(visible, 0);
+}
+function isPaginationWorthShowing(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const page = value;
+  return page.HasMore === true || typeof page.Offset === "number" && page.Offset > 0;
+}
+function markdownEnvelopeNotes(data) {
+  const envelope = data;
+  const notes = [];
+  const warning = envelope.Warning;
+  if (typeof warning === "string" && warning !== "") {
+    notes.push(`> **Warning:** ${warning}`);
+  }
+  const instructions = envelope.Instructions;
+  if (typeof instructions === "string" && instructions !== "") {
+    notes.push(`> ${instructions}`);
+  }
+  const pagination = envelope.Pagination;
+  if (isPaginationWorthShowing(pagination)) {
+    const body = markdownObject(pagination, 1);
+    if (body !== "") {
+      notes.push(`${markdownHeading(0)} Pagination
+${body}`);
+    }
+  }
+  const log = envelope.Log;
+  if (typeof log === "string" && log !== "") {
+    notes.push(`**Log:** ${log}`);
+  }
+  return notes;
+}
+function renderMarkdown(data) {
+  if (data.Result !== RESULTS.Success) {
+    const failure = data;
+    const sections = [`**Failed:** ${failure.Message}`];
+    if (failure.Data != null) {
+      sections.push(markdownPayload(failure.Data));
+    }
+    if (failure.Instructions) {
+      sections.push(`> ${failure.Instructions}`);
+    }
+    return sections.filter((section) => section !== "").join(`
+`);
+  }
+  if (!("Data" in data) || data.Data == null) {
+    return markdownObject(withoutPlumbing(data), 0);
+  }
+  return [markdownPayload(data.Data), ...markdownEnvelopeNotes(data)].filter((section) => section !== "").join(`
+`);
+}
 function toYaml(data) {
   const codec = getYamlCodec();
   if (!codec) {
@@ -11064,16 +11311,7 @@ var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) =
     errorMessage: location.source === "absolute" ? `Environment file not found: ${envFilePath}` : `Unable to locate environment file: ${envFilePath}. Run 'uip login' to authenticate.`
   };
 };
-var loadEnvFileAsync = async ({ envPath }) => {
-  const fs2 = getFileSystem();
-  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.cwd(), envPath);
-  if (!await fs2.exists(absolutePath)) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
-  const content = await fs2.readFile(absolutePath, "utf-8");
-  if (content === null) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
+var parseEnvContent = (content) => {
   const env = {};
   for (const line of content.split(`
 `)) {
@@ -11094,6 +11332,18 @@ var loadEnvFileAsync = async ({ envPath }) => {
   }
   return env;
 };
+var loadEnvFileAsync = async ({ envPath }) => {
+  const fs2 = getFileSystem();
+  const absolutePath = fs2.path.isAbsolute(envPath) ? envPath : fs2.path.join(fs2.env.cwd(), envPath);
+  if (!await fs2.exists(absolutePath)) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  const content = await fs2.readFile(absolutePath, "utf-8");
+  if (content === null) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  return parseEnvContent(content);
+};
 var saveEnvFileAsync = async ({
   envPath,
   data,
@@ -12043,7 +12293,7 @@ var allowsEval = cached(() => {
     return false;
   }
 });
-function isPlainObject(o) {
+function isPlainObject$1(o) {
   if (isObject(o) === false)
     return false;
   const ctor = o.constructor;
@@ -12060,7 +12310,7 @@ function isPlainObject(o) {
   return true;
 }
 function shallowClone(o) {
-  if (isPlainObject(o))
+  if (isPlainObject$1(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -12148,7 +12398,7 @@ function omit(schema, mask) {
   return clone(schema, def);
 }
 function extend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject$1(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks = schema._zod.def.checks;
@@ -12171,7 +12421,7 @@ function extend(schema, shape) {
   return clone(schema, def);
 }
 function safeExtend(schema, shape) {
-  if (!isPlainObject(shape)) {
+  if (!isPlainObject$1(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs(schema._zod.def, {
@@ -12508,6 +12758,7 @@ var string$1 = (params) => {
   const regex = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex}$`);
 };
+var boolean$1 = /^(?:true|false)$/i;
 var lowercase = /^[^A-Z]*$/;
 var uppercase = /^[^a-z]*$/;
 var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
@@ -13176,6 +13427,26 @@ var $ZodJWT = /* @__PURE__ */ $constructor("$ZodJWT", (inst, def) => {
     });
   };
 });
+var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+  $ZodType.init(inst, def);
+  inst._zod.pattern = boolean$1;
+  inst._zod.parse = (payload, _ctx) => {
+    if (def.coerce)
+      try {
+        payload.value = Boolean(payload.value);
+      } catch (_) {}
+    const input = payload.value;
+    if (typeof input === "boolean")
+      return payload;
+    payload.issues.push({
+      expected: "boolean",
+      code: "invalid_type",
+      input,
+      inst
+    });
+    return payload;
+  };
+});
 var $ZodUnknown = /* @__PURE__ */ $constructor("$ZodUnknown", (inst, def) => {
   $ZodType.init(inst, def);
   inst._zod.parse = (payload) => payload;
@@ -13546,7 +13817,7 @@ function mergeValues(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject(a) && isPlainObject(b)) {
+  if (isPlainObject$1(a) && isPlainObject$1(b)) {
     const bKeys = Object.keys(b);
     const sharedKeys = Object.keys(a).filter((key) => bKeys.indexOf(key) !== -1);
     const newObj = { ...a, ...b };
@@ -13901,7 +14172,7 @@ function handleRefineResult(result, payload, input, inst) {
     payload.issues.push(issue(_iss));
   }
 }
-var _a;
+var _a$1;
 class $ZodRegistry {
   constructor() {
@@ -13946,7 +14217,7 @@ class $ZodRegistry {
 function registry2() {
   return new $ZodRegistry;
 }
-(_a = globalThis).__zod_globalRegistry ?? (_a.__zod_globalRegistry = registry2());
+(_a$1 = globalThis).__zod_globalRegistry ?? (_a$1.__zod_globalRegistry = registry2());
 var globalRegistry = globalThis.__zod_globalRegistry;
 function _string(Class, params) {
   return new Class({
@@ -14191,6 +14462,12 @@ function _isoDuration(Class, params) {
     ...normalizeParams(params)
   });
 }
+function _boolean(Class, params) {
+  return new Class({
+    type: "boolean",
+    ...normalizeParams(params)
+  });
+}
 function _unknown(Class) {
   return new Class({
     type: "unknown"
@@ -14356,7 +14633,7 @@ function initializeContext(params) {
   };
 }
 function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
-  var _a2;
+  var _a;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
   if (seen) {
@@ -14404,7 +14681,7 @@ function process2(schema, ctx, _params = { path: [], schemaPath: [] }) {
     delete result.schema.default;
   }
   if (ctx.io === "input" && result.schema._prefault)
-    (_a2 = result.schema).default ?? (_a2.default = result.schema._prefault);
+    (_a = result.schema).default ?? (_a.default = result.schema._prefault);
   delete result.schema._prefault;
   const _result = ctx.seen.get(schema);
   return _result.schema;
@@ -14721,6 +14998,9 @@ var stringProcessor = (schema, ctx, _json, _params) => {
     }
   }
 };
+var booleanProcessor = (_schema, _ctx, json, _params) => {
+  json.type = "boolean";
+};
 var neverProcessor = (_schema, _ctx, json, _params) => {
   json.not = {};
 };
@@ -15179,6 +15459,14 @@ var ZodJWT = /* @__PURE__ */ $constructor("ZodJWT", (inst, def) => {
   $ZodJWT.init(inst, def);
   ZodStringFormat.init(inst, def);
 });
+var ZodBoolean = /* @__PURE__ */ $constructor("ZodBoolean", (inst, def) => {
+  $ZodBoolean.init(inst, def);
+  ZodType.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json, params) => booleanProcessor(inst, ctx, json);
+});
+function boolean(params) {
+  return _boolean(ZodBoolean, params);
+}
 var ZodUnknown = /* @__PURE__ */ $constructor("ZodUnknown", (inst, def) => {
   $ZodUnknown.init(inst, def);
   ZodType.init(inst, def);
@@ -15489,7 +15777,8 @@ object({
   secret: string().optional(),
   clientId: string().optional(),
   redirectUri: string().url().optional(),
-  scope: string().optional()
+  scope: string().optional(),
+  enforceSso: boolean().optional()
 });
 class UiPathConfig {
@@ -15501,6 +15790,7 @@ class UiPathConfig {
     this.clientId = options.clientId;
     this.redirectUri = options.redirectUri;
     this.scope = options.scope;
+    this.enforceSso = options.enforceSso;
   }
 }
@@ -15703,6 +15993,7 @@ var TaskType;
   TaskType2["DocumentValidation"] = "DocumentValidationTask";
   TaskType2["DocumentClassification"] = "DocumentClassificationTask";
   TaskType2["DataLabeling"] = "DataLabelingTask";
+  TaskType2["QuickForm"] = "QuickFormTask";
 })(TaskType || (TaskType = {}));
 var TaskPriority;
 (function(TaskPriority2) {
@@ -15815,7 +16106,11 @@ var PROCESS_ENDPOINTS = {
 var QUEUE_ENDPOINTS = {
   GET_BY_FOLDER: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions`,
   GET_ALL: `${ORCHESTRATOR_BASE}/odata/QueueDefinitions/UiPath.Server.Configuration.OData.GetQueuesAcrossFolders`,
-  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`
+  GET_BY_ID: (id) => `${ORCHESTRATOR_BASE}/odata/QueueDefinitions(${id})`,
+  GET_ITEMS: `${ORCHESTRATOR_BASE}/odata/QueueItems`,
+  ADD_ITEM: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.AddQueueItem`,
+  START_TRANSACTION: `${ORCHESTRATOR_BASE}/odata/Queues/UiPathODataSvc.StartTransaction`,
+  SET_TRANSACTION_RESULT: (itemId) => `${ORCHESTRATOR_BASE}/odata/Queues(${itemId})/UiPathODataSvc.SetTransactionResult`
 };
 var JOB_ENDPOINTS = {
   GET_ALL: `${ORCHESTRATOR_BASE}/odata/Jobs`,
@@ -15862,6 +16157,10 @@ var MAESTRO_ENDPOINTS = {
   TRACES: {
     GET_SPANS: (traceId) => `${LLMOPS_BASE}/api/Traces/spans?traceId=${traceId}`
   },
+  BUSINESS_APPS: {
+    COLLECTION: `${PIMS_BASE}/api/v1/business-apps`,
+    BY_ID: (businessAppId) => `${PIMS_BASE}/api/v1/business-apps/${businessAppId}`
+  },
   CASES: {
     GET_CASE_JSON: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/case-json`,
     GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/element-executions/case-instances/${instanceId}`,
@@ -15896,13 +16195,24 @@ var DATA_FABRIC_ENDPOINTS = {
     DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
     UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
     DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
-    UPDATE_METADATA: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}/metadata`,
+    UPDATE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}/metadata`,
     QUERY_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/query`,
     QUERY_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/query`,
     BULK_UPLOAD_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/bulk-upload`,
     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}`
+    DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
+    GET_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/Entity/${entityName}/metadata`,
+    GET_ENTITY_RECORDS_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/read`,
+    GET_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/v2/EntityService/${entityName}/read/${recordId}`,
+    INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/insert`,
+    BATCH_INSERT_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/insert-batch`,
+    UPDATE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/update/${recordId}`,
+    UPDATE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/update-batch`,
+    DELETE_RECORD_BY_NAME: (entityName, recordId) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/delete/${recordId}`,
+    DELETE_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/delete-batch`,
+    BULK_UPLOAD_BY_NAME: (entityName) => `${DATAFABRIC_BASE}/api/EntityService/${entityName}/bulk-upload`,
+    ATTACHMENT_BY_NAME: (entityName, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/${entityName}/${recordId}/${fieldName}`
   },
   CHOICESETS: {
     GET_ALL: `${DATAFABRIC_BASE}/api/Entity/choiceset`,
@@ -15925,7 +16235,8 @@ var DATA_FABRIC_ENDPOINTS = {
 };
 var IDENTITY_ENDPOINTS = {
   TOKEN: `${IDENTITY_BASE}/connect/token`,
-  AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`
+  AUTHORIZE: `${IDENTITY_BASE}/connect/authorize`,
+  END_SESSION: `${IDENTITY_BASE}/connect/endsession`
 };
 var TASK_TYPE_ENDPOINTS = {
   [TaskType.Form]: TASK_ENDPOINTS.GET_TASK_FORM_BY_ID,
@@ -15933,7 +16244,8 @@ var TASK_TYPE_ENDPOINTS = {
   [TaskType.DocumentValidation]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
   [TaskType.DocumentClassification]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
   [TaskType.External]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
-  [TaskType.DataLabeling]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID
+  [TaskType.DataLabeling]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+  [TaskType.QuickForm]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID
 };
 var ActionCenterEventNames;
 (function(ActionCenterEventNames2) {
@@ -15941,29 +16253,12 @@ var ActionCenterEventNames;
   ActionCenterEventNames2["REFRESHTOKEN"] = "AC.refreshToken";
 })(ActionCenterEventNames || (ActionCenterEventNames = {}));
 var AUTHENTICATION_TIMEOUT = 8000;
-var ALLOWED_HOST_ORIGINS = new Set([
-  "https://alpha.uipath.com",
-  "https://staging.uipath.com",
-  "https://cloud.uipath.com"
-]);
-function isValidHostOrigin(origin) {
-  if (!origin)
-    return false;
-  if (ALLOWED_HOST_ORIGINS.has(origin))
-    return true;
-  try {
-    return new URL(origin).hostname === "localhost";
-  } catch {
-    console.warn("isValidHostOrigin: received a malformed origin URL", origin);
-    return false;
-  }
-}
 function isTokenExpired(tokenInfo) {
   if (!tokenInfo?.expiresAt)
     return true;
   return new Date >= tokenInfo.expiresAt;
 }
-var trustedEmbeddingOrigin = isHostEmbedded && embeddingOrigin && isValidHostOrigin(embeddingOrigin) ? embeddingOrigin : null;
+var hostEmbeddingOrigin = isHostEmbedded && embeddingOrigin ? embeddingOrigin : null;
 function waitForMessage(filter, signal) {
   return new Promise((resolve2, reject) => {
     const handler = (event) => {
@@ -16032,12 +16327,6 @@ class ActionCenterTokenManager {
         statusCode: HttpStatus.UNAUTHORIZED
       }));
     }
-    if (!isValidHostOrigin(parentOrigin)) {
-      return Promise.reject(new AuthenticationError({
-        message: "Cannot refresh token: basedomain is not a trusted UiPath host origin",
-        statusCode: HttpStatus.UNAUTHORIZED
-      }));
-    }
     const { promise } = requestHostToken({
       pinnedOrigin: parentOrigin,
       sendRequest: () => this.sendMessageToParent(ActionCenterEventNames.REFRESHTOKEN, {
@@ -16061,7 +16350,7 @@ class ActionCenterTokenManager {
     }
   }
   sendMessageToParent(eventType, content) {
-    if (window.parent && isValidHostOrigin(this.parentOrigin)) {
+    if (window.parent && this.parentOrigin) {
       try {
         window.parent.postMessage({ eventType, content }, this.parentOrigin);
       } catch (error) {
@@ -16141,7 +16430,7 @@ class EmbeddedTokenManager {
     this.cancelRefresh?.();
   }
 }
-var SDK_VERSION = "1.6.1";
+var SDK_VERSION = "1.7.1";
 var CLOUD_ROLE_NAME = "uipath-ts-sdk";
 var SDK_SERVICE_NAME = "UiPath.TypeScript.Sdk";
 var SDK_LOGGER_NAME = "uipath-ts-sdk-telemetry";
@@ -16207,19 +16496,21 @@ function base64UrlToBase64(value) {
   const base642 = value.replace(BASE64URL_DASH_RE, "+").replace(BASE64URL_UNDERSCORE_RE, "/");
   return base642.padEnd(base642.length + (4 - base642.length % 4) % 4, "=");
 }
-function extractUserIdFromToken(token) {
+function decodeJwtClaims(token) {
   try {
-    const payload = token.split(".")[1];
+    const payload = token?.split(".")[1];
     if (!payload) {
-      return "";
+      return;
     }
-    const claims = JSON.parse(decodeBase64(base64UrlToBase64(payload)));
-    const sub = claims["sub"];
-    return typeof sub === "string" && sub ? sub : "";
+    return JSON.parse(decodeBase64(base64UrlToBase64(payload)));
   } catch {
-    return "";
+    return;
   }
 }
+function extractUserIdFromToken(token) {
+  const sub = decodeJwtClaims(token)?.["sub"];
+  return typeof sub === "string" && sub ? sub : "";
+}
 class TokenManager {
   constructor(executionContext, config2, isOAuth = false) {
@@ -16232,8 +16523,8 @@ class TokenManager {
     if (isInActionCenter) {
       this.actionCenterTokenManager = new ActionCenterTokenManager(config2, (tokenInfo) => this.setToken(tokenInfo));
       this.isOAuth = false;
-    } else if (trustedEmbeddingOrigin) {
-      this.embeddedTokenManager = new EmbeddedTokenManager(trustedEmbeddingOrigin, config2, (tokenInfo) => this.setToken(tokenInfo));
+    } else if (hostEmbeddingOrigin) {
+      this.embeddedTokenManager = new EmbeddedTokenManager(hostEmbeddingOrigin, config2, (tokenInfo) => this.setToken(tokenInfo));
       this.isOAuth = false;
     }
   }
@@ -16344,6 +16635,9 @@ class TokenManager {
   getToken() {
     return this.currentToken?.token;
   }
+  getIdToken() {
+    return this.currentToken?.idToken;
+  }
   hasValidToken() {
     if (!this.currentToken) {
       return false;
@@ -16415,11 +16709,13 @@ class TokenManager {
       token: token.access_token,
       type: "oauth",
       expiresAt: new Date(Date.now() + token.expires_in * 1000),
-      refreshToken: token.refresh_token
+      refreshToken: token.refresh_token,
+      idToken: token.id_token ?? tokenInfo.idToken
     });
     return token;
   }
 }
+var GUID_REGEX$1 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 class AuthService {
   constructor(config2, executionContext) {
@@ -16553,7 +16849,11 @@ class AuthService {
   hasValidToken() {
     return this.tokenManager.hasValidToken();
   }
-  logout() {
+  logout(options) {
+    const idTokenHint = options?.endSession ? this.tokenManager.getIdToken() : undefined;
+    if (options?.endSession && isBrowser2 && !idTokenHint) {
+      console.warn("endSession skipped — no OIDC ID token is available for this " + "session. Sign in again to enable it; only local authentication " + "state was cleared.");
+    }
     this.tokenManager.clearToken();
     if (isBrowser2) {
       try {
@@ -16563,6 +16863,12 @@ class AuthService {
         console.warn("Failed to clear OAuth context from session storage", error);
       }
     }
+    if (options?.endSession && isBrowser2 && idTokenHint) {
+      window.location.href = this._buildEndSessionUrl({
+        idTokenHint,
+        postLogoutRedirectUri: this.config.redirectUri
+      });
+    }
   }
   getToken() {
     if (!this.tokenManager.hasValidToken()) {
@@ -16606,10 +16912,27 @@ class AuthService {
       redirect_uri: params.redirectUri,
       code_challenge: params.codeChallenge,
       code_challenge_method: "S256",
-      scope: params.scope + " offline_access",
+      scope: params.scope + " offline_access openid",
       state: params.state || this.generateCodeVerifier().slice(0, 16)
     });
-    return `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+    const authorizeUrl = `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+    if (!this.config.enforceSso) {
+      return authorizeUrl;
+    }
+    const orgName = this.config.orgName;
+    if (!GUID_REGEX$1.test(orgName)) {
+      console.warn(`[UiPath SDK] enforceSso was ignored: orgName "${orgName}" is not an organization id. ` + "Pass the organization id (GUID) as orgName to sign in through the org's identity provider.");
+      return authorizeUrl;
+    }
+    return `${authorizeUrl}&acr_values=${encodeURIComponent(`tenant:${orgName}`)}`;
+  }
+  _buildEndSessionUrl(params) {
+    const queryParams = new URLSearchParams;
+    queryParams.set("id_token_hint", params.idTokenHint);
+    if (params.postLogoutRedirectUri) {
+      queryParams.set("post_logout_redirect_uri", params.postLogoutRedirectUri);
+    }
+    return `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.END_SESSION}?${queryParams.toString()}`;
   }
   async _getAccessToken(params) {
     const body = new URLSearchParams({
@@ -16636,7 +16959,8 @@ class AuthService {
       token: token.access_token,
       type: "oauth",
       expiresAt: token.expires_in ? new Date(Date.now() + token.expires_in * 1000) : undefined,
-      refreshToken: token.refresh_token
+      refreshToken: token.refresh_token,
+      idToken: token.id_token
     });
     return token;
   }
@@ -16709,9 +17033,18 @@ function validateConfig(config2) {
 function isCompleteConfig(config2) {
   return hasRequiredBaseFields(config2) && hasValidAuthConfig(config2);
 }
+function compactConfig(config2) {
+  return Object.fromEntries(Object.entries(config2).filter(([, value]) => value !== undefined));
+}
 function normalizeBaseUrl2(url) {
   return url.endsWith("/") ? url.slice(0, -1) : url;
 }
+function missingConfigMessage() {
+  if (isBrowser2) {
+    return "UiPath SDK configuration not found. " + "Ensure @uipath/coded-apps plugin is set up in your bundler to inject configuration during development and build.";
+  }
+  return "UiPath SDK configuration not found. " + "In a UiPath coded function, pass the handler context: new UiPath(ctx). " + "Otherwise pass { baseUrl, orgName, tenantName, secret }, " + "or set UIPATH_BASE_URL, UIPATH_ORG_NAME, UIPATH_TENANT_NAME and UIPATH_ACCESS_TOKEN.";
+}
 var REGISTRY_KEY2 = Symbol.for("@uipath/sdk-internals-registry");
 var getGlobalStore = () => {
   const globalObj = globalThis;
@@ -16720,6 +17053,7 @@ var getGlobalStore = () => {
   }
   return globalObj[REGISTRY_KEY2];
 };
+var looksLikeUiPath = (instance) => typeof instance.initialize === "function";
 class SDKInternalsRegistry {
   static get store() {
@@ -16731,6 +17065,9 @@ class SDKInternalsRegistry {
   static get(instance) {
     const internals = this.store.get(instance);
     if (!internals) {
+      if (looksLikeUiPath(instance)) {
+        throw new Error("Cannot create a service: the UiPath instance was never configured. " + missingConfigMessage());
+      }
       throw new Error("Invalid SDK instance. Make sure to pass a valid UiPath instance to the service constructor.");
     }
     return internals;
@@ -16748,6 +17085,10 @@ var UiPathMetaTags;
   UiPathMetaTags2["APP_BASE"] = "uipath:app-base";
   UiPathMetaTags2["FOLDER_KEY"] = "uipath:folder-key";
 })(UiPathMetaTags || (UiPathMetaTags = {}));
+var UiPathElementIds;
+(function(UiPathElementIds2) {
+  UiPathElementIds2["RESOURCE_OVERRIDES"] = "uipath-overrides";
+})(UiPathElementIds || (UiPathElementIds = {}));
 function getMetaTagContent(name) {
   if (!isBrowser2)
     return;
@@ -16768,7 +17109,54 @@ function loadFromMetaTags() {
   const hasAnyValue = Object.values(config2).some(Boolean);
   return hasAnyValue ? config2 : null;
 }
+function readEnv(name) {
+  const globals = globalThis;
+  try {
+    const fromNode = globals.process?.env?.[name];
+    if (fromNode)
+      return fromNode;
+  } catch {}
+  try {
+    const fromDeno = globals.Deno?.env?.get?.(name);
+    if (fromDeno)
+      return fromDeno;
+  } catch {}
+  return;
+}
+var UiPathEnvVars = {
+  BASE_URL: "UIPATH_BASE_URL",
+  ORG_NAME: "UIPATH_ORG_NAME",
+  TENANT_NAME: "UIPATH_TENANT_NAME",
+  ACCESS_TOKEN: "UIPATH_ACCESS_TOKEN"
+};
+function loadFromEnvironment() {
+  if (isBrowser2)
+    return null;
+  const config2 = {
+    baseUrl: readEnv(UiPathEnvVars.BASE_URL),
+    orgName: readEnv(UiPathEnvVars.ORG_NAME),
+    tenantName: readEnv(UiPathEnvVars.TENANT_NAME),
+    secret: readEnv(UiPathEnvVars.ACCESS_TOKEN)
+  };
+  return Object.values(config2).some(Boolean) ? config2 : null;
+}
+function isFunctionContext(value) {
+  return "platform" in value || "robot" in value;
+}
+function configFromFunctionContext(context) {
+  const { platform, robot } = context;
+  if (!platform)
+    return null;
+  const config2 = {
+    baseUrl: platform.baseUrl,
+    orgName: platform.orgId,
+    tenantName: platform.tenantId,
+    secret: robot?.accessToken ?? undefined
+  };
+  return Object.values(config2).some(Boolean) ? config2 : null;
+}
 var _UiPath_instances;
+var _a;
 var _UiPath_config;
 var _UiPath_authService;
 var _UiPath_initialized;
@@ -16777,6 +17165,7 @@ var _UiPath_metaFolderKey;
 var _UiPath_metaOrgId;
 var _UiPath_metaTenantId;
 var _UiPath_initializeWithConfig;
+var _UiPath_mergeConfigSources;
 var _UiPath_loadConfig;
 var UiPath$1 = class UiPath {
   constructor(config2) {
@@ -16788,15 +17177,16 @@ var UiPath$1 = class UiPath {
     _UiPath_metaFolderKey.set(this, undefined);
     _UiPath_metaOrgId.set(this, undefined);
     _UiPath_metaTenantId.set(this, undefined);
+    const resolved = config2 && isFunctionContext(config2) ? configFromFunctionContext(config2) ?? undefined : config2;
     const configFromMetaTags = loadFromMetaTags();
     __classPrivateFieldSet(this, _UiPath_metaFolderKey, configFromMetaTags?.folderKey, "f");
     __classPrivateFieldSet(this, _UiPath_metaOrgId, configFromMetaTags?.orgName, "f");
     __classPrivateFieldSet(this, _UiPath_metaTenantId, configFromMetaTags?.tenantName, "f");
-    const mergedConfig = config2 ? { ...configFromMetaTags, ...config2 } : configFromMetaTags;
+    const mergedConfig = __classPrivateFieldGet(_a, _a, "m", _UiPath_mergeConfigSources).call(_a, configFromMetaTags, resolved);
     if (mergedConfig && isCompleteConfig(mergedConfig)) {
       __classPrivateFieldGet(this, _UiPath_instances, "m", _UiPath_initializeWithConfig).call(this, mergedConfig);
-    } else if (config2) {
-      __classPrivateFieldSet(this, _UiPath_partialConfig, config2, "f");
+    } else if (resolved) {
+      __classPrivateFieldSet(this, _UiPath_partialConfig, resolved, "f");
     }
   }
   async initialize() {
@@ -16861,18 +17251,18 @@ var UiPath$1 = class UiPath {
   destroy() {
     __classPrivateFieldGet(this, _UiPath_authService, "f")?.getTokenManager()?.destroy();
   }
-  logout() {
+  logout(options) {
     if (__classPrivateFieldGet(this, _UiPath_config, "f") && hasSecretConfig(__classPrivateFieldGet(this, _UiPath_config, "f"))) {
       return;
     }
-    __classPrivateFieldGet(this, _UiPath_authService, "f")?.logout();
+    __classPrivateFieldGet(this, _UiPath_authService, "f")?.logout(options);
     __classPrivateFieldSet(this, _UiPath_initialized, false, "f");
   }
   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_metaFolderKey = new WeakMap, _UiPath_metaOrgId = new WeakMap, _UiPath_metaTenantId = new WeakMap, _UiPath_instances = new WeakSet, _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig2(config2) {
+_a = UiPath$1, _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initialized = new WeakMap, _UiPath_partialConfig = new WeakMap, _UiPath_metaFolderKey = new WeakMap, _UiPath_metaOrgId = new WeakMap, _UiPath_metaTenantId = new WeakMap, _UiPath_instances = new WeakSet, _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig2(config2) {
   validateConfig(config2);
   const hasSecretAuth = hasSecretConfig(config2);
   const hasOAuthAuth = hasOAuthConfig(config2);
@@ -16883,7 +17273,8 @@ _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initial
     secret: hasSecretAuth ? config2.secret : undefined,
     clientId: hasOAuthAuth ? config2.clientId : undefined,
     redirectUri: hasOAuthAuth ? config2.redirectUri : undefined,
-    scope: hasOAuthAuth ? config2.scope : undefined
+    scope: hasOAuthAuth ? config2.scope : undefined,
+    enforceSso: config2.enforceSso
   });
   const executionContext = new ExecutionContext;
   __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
@@ -16909,18 +17300,35 @@ _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initial
     redirectUri: hasOAuthAuth ? config2.redirectUri : undefined
   });
   trackEvent("Sdk.Auth");
-  if (hasSecretAuth || isInActionCenter || trustedEmbeddingOrigin) {
+  if (hasSecretAuth || isInActionCenter || hostEmbeddingOrigin) {
     __classPrivateFieldGet(this, _UiPath_authService, "f").authenticateWithSecret(config2.secret ?? "");
     __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
   }
+}, _UiPath_mergeConfigSources = function _UiPath_mergeConfigSources2(metaConfig, config2) {
+  const layers = [loadFromEnvironment(), metaConfig, config2].filter((layer) => Boolean(layer)).map((layer) => compactConfig(layer));
+  if (layers.length === 0)
+    return;
+  const merged = layers.reduce((acc, layer) => ({ ...acc, ...layer }), {});
+  const namesSecret = config2 ? hasSecretConfig(config2) : false;
+  const namesOAuth = Boolean(config2?.clientId || config2?.redirectUri || config2?.scope);
+  if (namesSecret !== namesOAuth) {
+    if (namesSecret) {
+      delete merged.clientId;
+      delete merged.redirectUri;
+      delete merged.scope;
+    } else {
+      delete merged.secret;
+    }
+  }
+  return merged;
 }, _UiPath_loadConfig = function _UiPath_loadConfig2() {
   const metaConfig = loadFromMetaTags();
   __classPrivateFieldSet(this, _UiPath_metaFolderKey, metaConfig?.folderKey, "f");
   __classPrivateFieldSet(this, _UiPath_metaOrgId, metaConfig?.orgName, "f");
   __classPrivateFieldSet(this, _UiPath_metaTenantId, metaConfig?.tenantName, "f");
-  const merged = { ...metaConfig, ...__classPrivateFieldGet(this, _UiPath_partialConfig, "f") };
-  if (!isCompleteConfig(merged)) {
-    throw new Error("UiPath SDK configuration not found. " + "Ensure @uipath/coded-apps plugin is set up in your bundler to inject configuration during development and build.");
+  const merged = __classPrivateFieldGet(_a, _a, "m", _UiPath_mergeConfigSources).call(_a, metaConfig, __classPrivateFieldGet(this, _UiPath_partialConfig, "f"));
+  if (!merged || !isCompleteConfig(merged)) {
+    throw new Error(missingConfigMessage());
   }
   return merged;
 };
@@ -17098,8 +17506,177 @@ var RESPONSE_TYPES = {
   JSON: "json",
   TEXT: "text",
   BLOB: "blob",
-  ARRAYBUFFER: "arraybuffer"
+  ARRAYBUFFER: "arraybuffer",
+  STREAM: "stream"
+};
+function createParams(paramsObj = {}) {
+  const params = {};
+  for (const [key, value] of Object.entries(paramsObj)) {
+    if (value !== undefined && value !== null) {
+      params[key] = value;
+    }
+  }
+  return params;
+}
+function toSearchParams(params) {
+  const searchParams = new URLSearchParams;
+  if (!params)
+    return searchParams;
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined || value === null)
+      continue;
+    if (Array.isArray(value)) {
+      value.forEach((item) => {
+        if (item !== undefined && item !== null)
+          searchParams.append(key, String(item));
+      });
+    } else {
+      searchParams.append(key, String(value));
+    }
+  }
+  return searchParams;
+}
+var DEFAULT_RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRY_METHODS = ["GET", "HEAD", "PUT", "DELETE", "OPTIONS"];
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 2,
+  initialDelayMs: 500,
+  backoffStrategy: "exponential",
+  backoffFactor: 2,
+  backoffMaxDelayMs: 30000,
+  retryableStatusCodes: DEFAULT_RETRYABLE_STATUS_CODES,
+  retryMethods: DEFAULT_RETRY_METHODS,
+  retryNetworkErrors: true,
+  respectRetryAfter: true,
+  maxRetryAfterMs: Infinity
+};
+var DEFAULT_API_CLIENT_RETRY = {
+  ...DEFAULT_RETRY_OPTIONS,
+  maxRetries: 0
 };
+function resolveRetryOptions(settings, defaults = DEFAULT_RETRY_OPTIONS) {
+  if (!settings)
+    return defaults;
+  const { retryDelay, useExponentialBackoff, ...live } = settings;
+  const resolved = { ...defaults };
+  for (const [key, value] of Object.entries(live)) {
+    if (value !== undefined) {
+      resolved[key] = value;
+    }
+  }
+  if (retryDelay !== undefined && live.initialDelayMs === undefined) {
+    resolved.initialDelayMs = retryDelay;
+  }
+  if (useExponentialBackoff !== undefined && live.backoffStrategy === undefined) {
+    resolved.backoffStrategy = useExponentialBackoff ? "exponential" : "constant";
+  }
+  return resolved;
+}
+function computeBackoffDelay(attempt, settings) {
+  const base = Math.max(0, settings.initialDelayMs);
+  let delay;
+  switch (settings.backoffStrategy) {
+    case "constant":
+      delay = base;
+      break;
+    case "linear":
+      delay = base * (attempt + 1);
+      break;
+    default:
+      delay = base * Math.pow(settings.backoffFactor, attempt);
+  }
+  return Math.min(delay, settings.backoffMaxDelayMs);
+}
+function parseRetryAfter(value, now = Date.now()) {
+  const trimmed = value?.trim();
+  if (!trimmed)
+    return;
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds))
+    return Math.max(0, seconds * 1000);
+  const date2 = Date.parse(trimmed);
+  if (Number.isNaN(date2))
+    return;
+  return Math.max(0, date2 - now);
+}
+function wait(durationMs) {
+  return new Promise((resolve2) => setTimeout(resolve2, Math.max(0, durationMs)));
+}
+var RETRY_AFTER = "retry-after";
+function createAttemptSignal(timeoutMs, external) {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+    return { signal: external, dispose: () => {} };
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
+  const onExternalAbort = () => controller.abort(external?.reason);
+  if (external) {
+    if (external.aborted) {
+      controller.abort(external.reason);
+    } else {
+      external.addEventListener("abort", onExternalAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      external?.removeEventListener("abort", onExternalAbort);
+    }
+  };
+}
+function delayBeforeRetry(durationMs, signal) {
+  if (!signal)
+    return wait(durationMs);
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve2, reject) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", onAbort);
+      resolve2();
+    }, Math.max(0, durationMs));
+    signal.addEventListener("abort", onAbort);
+  });
+}
+async function fetchWithRetry(url, init, options) {
+  const settings = options.retry;
+  const method = (init.method ?? "GET").toUpperCase();
+  const retriesAllowed = settings.retryMethods.includes(method) ? Math.max(0, settings.maxRetries) : 0;
+  let attempt = 0;
+  for (;; ) {
+    const { signal, dispose } = createAttemptSignal(options.timeoutMs, options.signal);
+    let response;
+    let failure;
+    try {
+      response = await fetch(url, { ...init, signal });
+    } catch (error) {
+      failure = error;
+    } finally {
+      dispose();
+    }
+    if (options.signal?.aborted && failure !== undefined)
+      throw failure;
+    if (response && !settings.retryableStatusCodes.includes(response.status))
+      return response;
+    if (failure !== undefined && !settings.retryNetworkErrors)
+      throw failure;
+    if (attempt >= retriesAllowed) {
+      if (response)
+        return response;
+      throw failure;
+    }
+    const retryAfter = settings.respectRetryAfter && response ? parseRetryAfter(response.headers.get(RETRY_AFTER)) : undefined;
+    const delay = retryAfter !== undefined ? Math.min(retryAfter, settings.maxRetryAfterMs) : computeBackoffDelay(attempt, settings);
+    response?.body?.cancel().catch((error) => {
+      console.warn("[UiPath SDK] Could not release a discarded response body:", error);
+    });
+    await delayBeforeRetry(delay, options.signal);
+    attempt++;
+  }
+}
 class ApiClient {
   constructor(config2, executionContext, tokenManager, clientConfig = {}) {
@@ -17134,28 +17711,16 @@ class ApiClient {
       [UIPATH_TRACEPARENT_ID]: traceparentValue,
       ...options.headers
     };
-    const searchParams = new URLSearchParams;
-    if (options.params) {
-      Object.entries(options.params).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-          value.forEach((item) => searchParams.append(key, String(item)));
-        } else {
-          searchParams.append(key, String(value));
-        }
-      });
-    }
+    const searchParams = toSearchParams(options.params);
     const fullUrl = searchParams.toString() ? `${url}?${searchParams.toString()}` : url;
     let body = undefined;
     if (options.body) {
       body = isFormData ? options.body : JSON.stringify(options.body);
     }
+    const retrySettings = resolveRetryOptions(options.retry ?? options.retryOptions, DEFAULT_API_CLIENT_RETRY);
+    const timeoutMs = options.timeoutMs ?? options.timeoutOptions?.timeout;
     try {
-      const response = await fetch(fullUrl, {
-        method,
-        headers,
-        body,
-        signal: options.signal
-      });
+      const response = await fetchWithRetry(fullUrl, { method, headers, body }, { retry: retrySettings, timeoutMs, signal: options.signal });
       if (!response.ok) {
         const errorInfo = await errorResponseParser.parse(response);
         throw ErrorFactory.createFromHttpStatus(response.status, errorInfo);
@@ -17871,36 +18436,36 @@ function createEntityMethods(entityData, service) {
     async insertRecord(data, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.insertRecordById(entityData.id, data, options);
+      return service.insertRecord({ id: entityData.id }, data, options);
     },
     async insertRecords(data, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.insertRecordsById(entityData.id, data, options);
+      return service.insertRecords({ id: 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);
+      return service.updateRecord({ id: entityData.id }, recordId, data, options);
     },
     async updateRecords(data, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.updateRecordsById(entityData.id, data, options);
+      return service.updateRecords({ id: entityData.id }, data, options);
     },
     async deleteRecords(recordIds, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.deleteRecordsById(entityData.id, recordIds, options);
+      return service.deleteRecords({ id: entityData.id }, recordIds, options);
     },
     async deleteRecord(recordId, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
       if (!recordId)
         throw new Error("Record ID is undefined");
-      return service.deleteRecordById(entityData.id, recordId, options);
+      return service.deleteRecord({ id: entityData.id }, recordId, options);
     },
     async getAllRecords(options) {
       if (!entityData.id)
@@ -17917,27 +18482,27 @@ function createEntityMethods(entityData, service) {
     async downloadAttachment(recordId, fieldName, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.downloadAttachment(entityData.id, recordId, fieldName, options);
+      return service.downloadAttachment({ id: entityData.id }, recordId, fieldName, options);
     },
     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);
+      return service.uploadAttachment({ id: entityData.id }, recordId, fieldName, file, options);
     },
     async deleteAttachment(recordId, fieldName, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.deleteAttachment(entityData.id, recordId, fieldName, options);
+      return service.deleteAttachment({ id: entityData.id }, recordId, fieldName, options);
     },
     async queryRecords(options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.queryRecordsById(entityData.id, options);
+      return service.queryRecords({ id: entityData.id }, options);
     },
     async importRecords(file, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.importRecordsById(entityData.id, file, options);
+      return service.importRecords({ id: entityData.id }, file, options);
     },
     async insert(data, options) {
       return this.insertRecord(data, options);
@@ -18013,6 +18578,15 @@ var EntityAggregateFunction;
   EntityAggregateFunction2["Min"] = "MIN";
   EntityAggregateFunction2["Max"] = "MAX";
 })(EntityAggregateFunction || (EntityAggregateFunction = {}));
+var EntityHavingOperator;
+(function(EntityHavingOperator2) {
+  EntityHavingOperator2["Equals"] = "=";
+  EntityHavingOperator2["NotEquals"] = "!=";
+  EntityHavingOperator2["GreaterThan"] = ">";
+  EntityHavingOperator2["GreaterThanOrEqual"] = ">=";
+  EntityHavingOperator2["LessThan"] = "<";
+  EntityHavingOperator2["LessThanOrEqual"] = "<=";
+})(EntityHavingOperator || (EntityHavingOperator = {}));
 var EntityType;
 (function(EntityType2) {
   EntityType2["Entity"] = "Entity";
@@ -18043,15 +18617,6 @@ var JoinType;
   JoinType2["LeftJoin"] = "LeftJoin";
   JoinType2["InnerJoin"] = "InnerJoin";
 })(JoinType || (JoinType = {}));
-function createParams(paramsObj = {}) {
-  const params = {};
-  for (const [key, value] of Object.entries(paramsObj)) {
-    if (value !== undefined && value !== null) {
-      params[key] = value;
-    }
-  }
-  return params;
-}
 var EntityFieldConstraint;
 (function(EntityFieldConstraint2) {
   EntityFieldConstraint2["LengthLimit"] = "lengthLimit";
@@ -18190,95 +18755,84 @@ function toWireJoin(join2, baseEntityName) {
     }
   };
 }
+function unwrapEntityRef(entityRef, callerLabel) {
+  const { id, name } = entityRef ?? {};
+  if (id && name) {
+    throw new ValidationError({
+      message: `${callerLabel}: entityRef must supply exactly one of 'id' or 'name', not both.`
+    });
+  }
+  if (id) {
+    return { byId: true, identifier: id };
+  }
+  if (name) {
+    return { byId: false, identifier: name };
+  }
+  throw new ValidationError({
+    message: `${callerLabel}: entityRef must supply exactly one of 'id' or 'name'.`
+  });
+}
 class EntityService extends BaseService {
   async getById(id, options) {
-    const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(id), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
-    const metadata = transformData(response.data, EntityMap);
-    this.applyFieldMappings(metadata);
-    return createEntityWithMethods(metadata, this);
+    return this.fetchEntityMetadata(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(id), options?.folderKey);
+  }
+  async getByName(entityName, options) {
+    return this.fetchEntityMetadata(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_NAME(entityName), options?.folderKey);
   }
   async getAllRecords(entityId, options) {
-    const { folderKey, ...rest } = options ?? {};
-    const downstreamOptions = options === undefined ? undefined : rest;
-    return PaginationHelpers.getAll({
-      serviceAccess: this.createPaginationServiceAccess(),
-      getEndpoint: () => DATA_FABRIC_ENDPOINTS.ENTITY.GET_ENTITY_RECORDS(entityId),
-      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
-      pagination: {
-        paginationType: PaginationType.OFFSET,
-        itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
-        totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
-        paginationParams: {
-          pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
-          offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
-          countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
-        }
-      },
-      excludeFromPrefix: ["expansionLevel"]
-    }, downstreamOptions);
+    return this.getRecordsImpl(true, entityId, options);
+  }
+  async getRecordsByName(entityName, options) {
+    return this.getRecordsImpl(false, entityName, options);
   }
   async getRecordById(entityId, recordId, options = {}) {
-    const params = createParams({
-      expansionLevel: options.expansionLevel
-    });
-    const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_RECORD_BY_ID(entityId, recordId), { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
-    return response.data;
+    return this.getRecordImpl(true, entityId, recordId, options);
+  }
+  async getRecordByName(entityName, recordId, options = {}) {
+    return this.getRecordImpl(false, entityName, recordId, options);
+  }
+  async insertRecord(entityRef, data, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.insertRecord");
+    return this.insertRecordImpl(byId, identifier, data, options);
   }
   async insertRecordById(id, data, options = {}) {
-    const params = createParams({
-      expansionLevel: options.expansionLevel
-    });
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.INSERT_BY_ID(id), data, {
-      params,
-      headers: createHeaders({ [FOLDER_KEY]: options.folderKey })
-    });
-    return response.data;
+    return this.insertRecordImpl(true, id, data, options);
+  }
+  async insertRecords(entityRef, data, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.insertRecords");
+    return this.insertRecordsImpl(byId, identifier, data, options);
   }
   async insertRecordsById(id, data, options = {}) {
-    const params = createParams({
-      expansionLevel: options.expansionLevel,
-      failOnFirst: options.failOnFirst
-    });
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.BATCH_INSERT_BY_ID(id), data, {
-      params,
-      headers: createHeaders({ [FOLDER_KEY]: options.folderKey })
-    });
-    return response.data;
+    return this.insertRecordsImpl(true, id, data, options);
+  }
+  async updateRecord(entityRef, recordId, data, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.updateRecord");
+    return this.updateRecordImpl(byId, identifier, recordId, data, options);
   }
   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,
-      headers: createHeaders({ [FOLDER_KEY]: options.folderKey })
-    });
-    return response.data;
+    return this.updateRecordImpl(true, entityId, recordId, data, options);
+  }
+  async updateRecords(entityRef, data, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.updateRecords");
+    return this.updateRecordsImpl(byId, identifier, data, options);
   }
   async updateRecordsById(id, data, options = {}) {
-    const params = createParams({
-      expansionLevel: options.expansionLevel,
-      failOnFirst: options.failOnFirst
-    });
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_BY_ID(id), data, {
-      params,
-      headers: createHeaders({ [FOLDER_KEY]: options.folderKey })
-    });
-    return response.data;
+    return this.updateRecordsImpl(true, id, data, options);
+  }
+  async deleteRecords(entityRef, recordIds, options = {}) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.deleteRecords");
+    return this.deleteRecordsImpl(byId, identifier, recordIds, options);
   }
   async deleteRecordsById(id, recordIds, options = {}) {
-    const params = createParams({
-      failOnFirst: options.failOnFirst
-    });
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_BY_ID(id), recordIds, {
-      params,
-      headers: createHeaders({ [FOLDER_KEY]: options.folderKey })
-    });
-    return response.data;
+    return this.deleteRecordsImpl(true, id, recordIds, options);
+  }
+  async deleteRecord(entityRef, recordId, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.deleteRecord");
+    return this.deleteRecordImpl(byId, identifier, recordId, options);
   }
   async deleteRecordById(entityId, recordId, options) {
-    await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_RECORD_BY_ID(entityId, recordId), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+    return this.deleteRecordImpl(true, entityId, recordId, options);
   }
   async getAll(options) {
     const endpoint = !options?.folderKey && options?.includeFolderEntities ? DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL_V2 : DATA_FABRIC_ENDPOINTS.ENTITY.GET_ALL;
@@ -18290,62 +18844,30 @@ class EntityService extends BaseService {
     });
     return entities;
   }
+  async queryRecords(entityRef, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.queryRecords");
+    return this.queryRecordsImpl(byId, identifier, options);
+  }
   async queryRecordsById(id, options) {
-    if (options?.joins && options.joins.length > MAX_QUERY_JOINS) {
-      throw new ValidationError({
-        message: `A maximum of ${MAX_QUERY_JOINS} joins is supported per query (received ${options.joins.length})`
-      });
-    }
-    if (options?.joins && options.joins.length > 0 && !options.selectedFields?.length && !options.aggregates?.length) {
-      throw new ValidationError({
-        message: 'Join queries require selectedFields or aggregates — reference fields as "<EntityName>.<FieldName>" (e.g. "Customer.name")'
-      });
-    }
-    const { folderKey, expansionLevel, ...rest } = options ?? {};
-    let getEndpoint = () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(id);
-    if (options?.joins && options.joins.length > 0) {
-      const baseEntityName = await this.resolveEntityName(id, folderKey);
-      rest.joins = options.joins.map((join2) => toWireJoin(join2, baseEntityName));
-      getEndpoint = () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_NAME(baseEntityName);
-    }
-    const downstreamOptions = options === undefined ? undefined : rest;
-    return PaginationHelpers.getAll({
-      serviceAccess: this.createPaginationServiceAccess(),
-      getEndpoint,
-      method: HTTP_METHODS.POST,
-      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
-      queryParams: createParams({ expansionLevel }),
-      pagination: {
-        paginationType: PaginationType.OFFSET,
-        itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
-        totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
-        paginationParams: {
-          pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
-          offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
-          countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
-        }
-      },
-      excludeFromPrefix: ["filterGroup", "selectedFields", "sortOptions", "aggregates", "groupBy", "joins"]
-    }, downstreamOptions);
+    return this.queryRecordsImpl(true, id, options);
+  }
+  async importRecords(entityRef, file, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.importRecords");
+    return this.importRecordsImpl(byId, identifier, file, options);
   }
   async importRecordsById(id, file, options) {
-    const formData = new FormData;
-    if (file instanceof Uint8Array) {
-      formData.append("file", new Blob([file.buffer]));
-    } else {
-      formData.append("file", file);
-    }
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.BULK_UPLOAD_BY_ID(id), formData, { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
-    return response.data;
+    return this.importRecordsImpl(true, id, file, options);
   }
-  async downloadAttachment(entityId, recordId, fieldName, options) {
-    const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.DOWNLOAD_ATTACHMENT(entityId, recordId, fieldName), {
+  async downloadAttachment(entityRef, recordId, fieldName, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.downloadAttachment");
+    const response = await this.get(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.DOWNLOAD_ATTACHMENT(identifier, recordId, fieldName) : DATA_FABRIC_ENDPOINTS.ENTITY.ATTACHMENT_BY_NAME(identifier, recordId, fieldName), {
       responseType: RESPONSE_TYPES.BLOB,
       headers: createHeaders({ [FOLDER_KEY]: options?.folderKey })
     });
     return response.data;
   }
-  async uploadAttachment(entityId, recordId, fieldName, file, options) {
+  async uploadAttachment(entityRef, recordId, fieldName, file, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.uploadAttachment");
     const formData = new FormData;
     if (file instanceof Uint8Array) {
       formData.append("file", new Blob([file.buffer]));
@@ -18353,14 +18875,15 @@ class EntityService extends BaseService {
       formData.append("file", file);
     }
     const params = createParams({ expansionLevel: options?.expansionLevel });
-    const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPLOAD_ATTACHMENT(entityId, recordId, fieldName), formData, {
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.UPLOAD_ATTACHMENT(identifier, recordId, fieldName) : DATA_FABRIC_ENDPOINTS.ENTITY.ATTACHMENT_BY_NAME(identifier, recordId, fieldName), formData, {
       params,
       headers: createHeaders({ [FOLDER_KEY]: options?.folderKey })
     });
     return response.data;
   }
-  async deleteAttachment(entityId, recordId, fieldName, options) {
-    const response = await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_ATTACHMENT(entityId, recordId, fieldName), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+  async deleteAttachment(entityRef, recordId, fieldName, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.deleteAttachment");
+    const response = await this.delete(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_ATTACHMENT(identifier, recordId, fieldName) : DATA_FABRIC_ENDPOINTS.ENTITY.ATTACHMENT_BY_NAME(identifier, recordId, fieldName), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
     return response.data;
   }
   async getRecordsById(entityId, options) {
@@ -18397,11 +18920,16 @@ class EntityService extends BaseService {
     const opts = options ?? {};
     const hasSchemaChanges = !!(opts.addFields?.length || opts.removeFields?.length || opts.updateFields?.length);
     const hasMetadataChanges = opts.displayName !== undefined || opts.description !== undefined || opts.isRbacEnabled !== undefined;
+    if (!hasSchemaChanges && !hasMetadataChanges) {
+      throw new ValidationError({
+        message: "updateById requires at least one change — pass addFields, removeFields, updateFields, displayName, description, or isRbacEnabled."
+      });
+    }
     if (hasSchemaChanges) {
       await this.applySchemaUpdate(id, opts);
     }
     if (hasMetadataChanges) {
-      await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_METADATA(id), {
+      await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE(id), {
         ...opts.displayName !== undefined && { displayName: opts.displayName },
         ...opts.description !== undefined && { description: opts.description },
         ...opts.isRbacEnabled !== undefined && { isRbacEnabled: opts.isRbacEnabled }
@@ -18414,10 +18942,24 @@ class EntityService extends BaseService {
     const raw = entityResponse.data;
     let fields = (raw.fields ?? []).filter((f) => !f.isSystemField && !f.isPrimaryKey);
     if (options.removeFields?.length) {
+      const existingNames = new Set(fields.map((f) => f.name));
+      const missing = options.removeFields.filter((r) => !existingNames.has(r.name)).map((r) => r.name);
+      if (missing.length) {
+        throw new ValidationError({
+          message: `Cannot remove field(s) — no matching non-system field found for name(s): ${missing.join(", ")}.`
+        });
+      }
       const removeSet = new Set(options.removeFields.map((r) => r.name));
       fields = fields.filter((f) => !removeSet.has(f.name));
     }
     if (options.updateFields?.length) {
+      const existingIds = new Set(fields.map((f) => f.id));
+      const missing = options.updateFields.filter((u) => !existingIds.has(u.id)).map((u) => u.id);
+      if (missing.length) {
+        throw new ValidationError({
+          message: `Cannot update field(s) — no matching non-system field found for id(s): ${missing.join(", ")}.`
+        });
+      }
       const updateMap = new Map(options.updateFields.map((u) => [u.id, u]));
       fields = fields.map((f) => {
         const update = updateMap.get(f.id ?? "");
@@ -18667,40 +19209,185 @@ class EntityService extends BaseService {
         return {};
     }
   }
+  async fetchEntityMetadata(endpoint, folderKey) {
+    const response = await this.get(endpoint, { headers: createHeaders({ [FOLDER_KEY]: folderKey }) });
+    const metadata = transformData(response.data, EntityMap);
+    this.applyFieldMappings(metadata);
+    return createEntityWithMethods(metadata, this);
+  }
+  getRecordsImpl(byId, identifier, options) {
+    const { folderKey, ...rest } = options ?? {};
+    const downstreamOptions = options === undefined ? undefined : rest;
+    return PaginationHelpers.getAll({
+      serviceAccess: this.createPaginationServiceAccess(),
+      getEndpoint: () => byId ? DATA_FABRIC_ENDPOINTS.ENTITY.GET_ENTITY_RECORDS(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.GET_ENTITY_RECORDS_BY_NAME(identifier),
+      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
+      pagination: {
+        paginationType: PaginationType.OFFSET,
+        itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
+        totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
+        paginationParams: {
+          pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+          offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
+          countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
+        }
+      },
+      excludeFromPrefix: ["expansionLevel"]
+    }, downstreamOptions);
+  }
+  async getRecordImpl(byId, identifier, recordId, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel });
+    const response = await this.get(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.GET_RECORD_BY_ID(identifier, recordId) : DATA_FABRIC_ENDPOINTS.ENTITY.GET_RECORD_BY_NAME(identifier, recordId), { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async insertRecordImpl(byId, identifier, data, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel });
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.INSERT_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.INSERT_BY_NAME(identifier), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async insertRecordsImpl(byId, identifier, data, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel, failOnFirst: options.failOnFirst });
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.BATCH_INSERT_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.BATCH_INSERT_BY_NAME(identifier), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async updateRecordImpl(byId, identifier, recordId, data, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel });
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_RECORD_BY_ID(identifier, recordId) : DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_RECORD_BY_NAME(identifier, recordId), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async updateRecordsImpl(byId, identifier, data, options) {
+    const params = createParams({ expansionLevel: options.expansionLevel, failOnFirst: options.failOnFirst });
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_BY_NAME(identifier), data, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async deleteRecordsImpl(byId, identifier, recordIds, options) {
+    const params = createParams({ failOnFirst: options.failOnFirst });
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_BY_NAME(identifier), recordIds, { params, headers: createHeaders({ [FOLDER_KEY]: options.folderKey }) });
+    return response.data;
+  }
+  async deleteRecordImpl(byId, identifier, recordId, options) {
+    await this.delete(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_RECORD_BY_ID(identifier, recordId) : DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_RECORD_BY_NAME(identifier, recordId), { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+  }
+  async queryRecordsImpl(byId, identifier, options) {
+    if (options?.joins && options.joins.length > MAX_QUERY_JOINS) {
+      throw new ValidationError({
+        message: `A maximum of ${MAX_QUERY_JOINS} joins is supported per query (received ${options.joins.length})`
+      });
+    }
+    if (options?.joins && options.joins.length > 0 && !options.selectedFields?.length && !options.aggregates?.length) {
+      throw new ValidationError({
+        message: 'Join queries require selectedFields or aggregates — reference fields as "<EntityName>.<FieldName>" (e.g. "Customer.name")'
+      });
+    }
+    if (options?.havingFilter && (!options.aggregates?.length || !options.groupBy?.length)) {
+      throw new ValidationError({
+        message: "havingFilter requires aggregates and groupBy — conditions reference declared aggregate aliases; use filterGroup for row-level conditions"
+      });
+    }
+    const { folderKey, expansionLevel, ...rest } = options ?? {};
+    let getEndpoint = () => byId ? DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_NAME(identifier);
+    if (options?.joins && options.joins.length > 0) {
+      const baseEntityName = byId ? await this.resolveEntityName(identifier, folderKey) : identifier;
+      rest.joins = options.joins.map((join2) => toWireJoin(join2, baseEntityName));
+      getEndpoint = () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_NAME(baseEntityName);
+    }
+    const downstreamOptions = options === undefined ? undefined : rest;
+    return PaginationHelpers.getAll({
+      serviceAccess: this.createPaginationServiceAccess(),
+      getEndpoint,
+      method: HTTP_METHODS.POST,
+      headers: createHeaders({ [FOLDER_KEY]: folderKey }),
+      queryParams: createParams({ expansionLevel }),
+      pagination: {
+        paginationType: PaginationType.OFFSET,
+        itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
+        totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
+        paginationParams: {
+          pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+          offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
+          countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
+        }
+      },
+      excludeFromPrefix: ["filterGroup", "selectedFields", "sortOptions", "aggregates", "groupBy", "joins", "havingFilter"]
+    }, downstreamOptions);
+  }
+  async importRecordsImpl(byId, identifier, file, options) {
+    const formData = new FormData;
+    if (file instanceof Uint8Array) {
+      formData.append("file", new Blob([file.buffer]));
+    } else {
+      formData.append("file", file);
+    }
+    const response = await this.post(byId ? DATA_FABRIC_ENDPOINTS.ENTITY.BULK_UPLOAD_BY_ID(identifier) : DATA_FABRIC_ENDPOINTS.ENTITY.BULK_UPLOAD_BY_NAME(identifier), formData, { headers: createHeaders({ [FOLDER_KEY]: options?.folderKey }) });
+    return response.data;
+  }
 }
 __decorate([
   track("Entities.GetById")
 ], EntityService.prototype, "getById", null);
+__decorate([
+  track("Entities.GetByName")
+], EntityService.prototype, "getByName", null);
 __decorate([
   track("Entities.GetAllRecords")
 ], EntityService.prototype, "getAllRecords", null);
+__decorate([
+  track("Entities.GetRecordsByName")
+], EntityService.prototype, "getRecordsByName", null);
 __decorate([
   track("Entities.GetRecordById")
 ], EntityService.prototype, "getRecordById", null);
+__decorate([
+  track("Entities.GetRecordByName")
+], EntityService.prototype, "getRecordByName", null);
+__decorate([
+  track("Entities.InsertRecord")
+], EntityService.prototype, "insertRecord", null);
 __decorate([
   track("Entities.InsertRecordById")
 ], EntityService.prototype, "insertRecordById", null);
+__decorate([
+  track("Entities.InsertRecords")
+], EntityService.prototype, "insertRecords", null);
 __decorate([
   track("Entities.InsertRecordsById")
 ], EntityService.prototype, "insertRecordsById", null);
+__decorate([
+  track("Entities.UpdateRecord")
+], EntityService.prototype, "updateRecord", null);
 __decorate([
   track("Entities.UpdateRecordById")
 ], EntityService.prototype, "updateRecordById", null);
+__decorate([
+  track("Entities.UpdateRecords")
+], EntityService.prototype, "updateRecords", null);
 __decorate([
   track("Entities.UpdateRecordsById")
 ], EntityService.prototype, "updateRecordsById", null);
+__decorate([
+  track("Entities.DeleteRecords")
+], EntityService.prototype, "deleteRecords", null);
 __decorate([
   track("Entities.DeleteRecordsById")
 ], EntityService.prototype, "deleteRecordsById", null);
+__decorate([
+  track("Entities.DeleteRecord")
+], EntityService.prototype, "deleteRecord", null);
 __decorate([
   track("Entities.DeleteRecordById")
 ], EntityService.prototype, "deleteRecordById", null);
 __decorate([
   track("Entities.GetAll")
 ], EntityService.prototype, "getAll", null);
+__decorate([
+  track("Entities.QueryRecords")
+], EntityService.prototype, "queryRecords", null);
 __decorate([
   track("Entities.QueryRecordsById")
 ], EntityService.prototype, "queryRecordsById", null);
+__decorate([
+  track("Entities.ImportRecords")
+], EntityService.prototype, "importRecords", null);
 __decorate([
   track("Entities.ImportRecordsById")
 ], EntityService.prototype, "importRecordsById", null);
@@ -20144,6 +20831,74 @@ function validateName2(resourceType, name) {
   }
   return trimmed;
 }
+var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asResourceOverrides(value) {
+  if (!isPlainObject(value))
+    return;
+  const table = {};
+  for (const [key, properties] of Object.entries(value)) {
+    if (!isPlainObject(properties))
+      continue;
+    const bag = {};
+    for (const [property, propertyValue] of Object.entries(properties)) {
+      if (typeof propertyValue === "string")
+        bag[property] = propertyValue;
+    }
+    table[key] = bag;
+  }
+  return Object.keys(table).length > 0 ? table : undefined;
+}
+function readFromDocument() {
+  if (!isBrowser2)
+    return;
+  const text = document.getElementById(UiPathElementIds.RESOURCE_OVERRIDES)?.textContent;
+  if (!text)
+    return;
+  try {
+    return asResourceOverrides(JSON.parse(text));
+  } catch (error) {
+    console.warn(`[UiPath SDK] Failed to parse <script id="${UiPathElementIds.RESOURCE_OVERRIDES}"> as JSON — proceeding without overrides:`, error);
+    return;
+  }
+}
+var table;
+var loaded = false;
+var pageOverrides = () => {
+  if (!loaded) {
+    loaded = true;
+    table = readFromDocument();
+  }
+  return table;
+};
+var RESOURCE_OVERWRITES_KEY = Symbol.for("uipath.resourceOverwrites.v1");
+function readOverrides() {
+  const slot2 = globalThis[RESOURCE_OVERWRITES_KEY];
+  const source = typeof slot2 === "function" ? slot2 : pageOverrides;
+  try {
+    return source();
+  } catch (error) {
+    console.warn("[UiPath SDK] Override source threw — proceeding without overrides:", error);
+    return;
+  }
+}
+function resolveOverride(resourceType, name, folderPath) {
+  const table2 = readOverrides();
+  if (!table2)
+    return;
+  const bindingType = resourceType.toLowerCase();
+  const scopedKey = folderPath ? `${bindingType}.${name}.${folderPath}` : undefined;
+  const unscopedKey = `${bindingType}.${name}`;
+  const entry = (scopedKey && table2[scopedKey]) ?? table2[unscopedKey];
+  if (!entry)
+    return;
+  return {
+    name: entry.name,
+    folderPath: entry.folderPath
+  };
+}
 var SINGLE_QUOTE_RE = /'/g;
 class FolderScopedService extends BaseService {
@@ -20160,20 +20915,23 @@ class FolderScopedService extends BaseService {
     }
     return response.data?.value;
   }
-  async getByNameLookup(resourceType, endpoint, name, options, transform2, responseFieldMap) {
+  async getByNameLookup(resourceType, endpoint, name, options, transform2, responseFieldMap, callerLabel) {
     const validatedName = validateName2(resourceType, name);
     const { folderId, folderKey, folderPath, ...queryOptions } = options;
+    const override = resolveOverride(resourceType, validatedName, folderPath);
+    const resolvedName = override?.name ?? validatedName;
+    const resolvedFolderPath = override?.folderPath ?? folderPath;
     const headers = resolveFolderHeaders({
       folderId,
       folderKey,
-      folderPath,
-      resourceType: `${resourceType}.getByName`,
+      folderPath: resolvedFolderPath,
+      resourceType: callerLabel ?? `${resourceType}.getByName`,
       fallbackFolderKey: this.config.folderKey
     });
     const apiFieldOptions = responseFieldMap ? transformOptions(queryOptions, responseFieldMap) : queryOptions;
     const apiOptions = {
       ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
-      $filter: `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
+      $filter: `Name eq '${resolvedName.replace(SINGLE_QUOTE_RE, "''")}'`,
       $top: "1"
     };
     const response = await this.get(endpoint, {
@@ -20182,12 +20940,48 @@ class FolderScopedService extends BaseService {
     });
     const items = response.data?.value;
     if (!items?.length) {
-      const folderHint = describeFolderForError(folderId, folderKey, folderPath);
+      const folderHint = describeFolderForError(folderId, folderKey, resolvedFolderPath);
       throw new NotFoundError({
-        message: `${resourceType} '${validatedName}' not found${folderHint}.`
+        message: `${resourceType} '${resolvedName}' not found${folderHint}.`
       });
     }
-    return transform2(items[0]);
+    return {
+      result: transform2(items[0]),
+      effectiveFolder: { folderId, folderKey, folderPath: resolvedFolderPath }
+    };
+  }
+  async getByKeyLookup(resourceType, endpoint, key, options, transform2, responseFieldMap, callerLabel) {
+    const label = callerLabel ?? `${resourceType}.getByKey`;
+    const trimmedKey = key?.trim();
+    if (!trimmedKey || !GUID_REGEX.test(trimmedKey)) {
+      throw new ValidationError({ message: `${label}: key must be a GUID.` });
+    }
+    const { folderId, folderKey, folderPath, ...queryOptions } = options;
+    const headers = resolveFolderHeaders({
+      folderId,
+      folderKey,
+      folderPath,
+      resourceType: label,
+      fallbackFolderKey: this.config.folderKey
+    });
+    const apiFieldOptions = responseFieldMap ? transformOptions(queryOptions, responseFieldMap) : queryOptions;
+    const apiOptions = {
+      ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
+      $filter: `Key eq ${trimmedKey}`,
+      $top: "1"
+    };
+    const response = await this.get(endpoint, {
+      headers,
+      params: apiOptions
+    });
+    const items = response.data?.value;
+    if (!items?.length) {
+      throw new NotFoundError({ message: `${resourceType} with key '${trimmedKey}' not found.` });
+    }
+    return {
+      result: transform2(items[0]),
+      effectiveFolder: { folderId, folderKey, folderPath }
+    };
   }
 }
 function describeFolderForError(folderId, folderKey, folderPath) {
@@ -20218,12 +21012,16 @@ class TaskService extends FolderScopedService {
     };
   }
   async create(task, folderId) {
+    if (task.type === TaskType.QuickForm && !task.taskSchemaKey) {
+      throw new ValidationError({ message: "taskSchemaKey is required when creating a QuickForm task." });
+    }
     const headers = createHeaders({ [FOLDER_ID]: folderId });
-    const externalTask = {
-      ...task,
-      type: TaskType.External
-    };
-    const response = await this.post(TASK_ENDPOINTS.CREATE_GENERIC_TASK, externalTask, { headers });
+    const { labels, type, ...rest } = task;
+    const payload = { ...rest, type: type ?? TaskType.External };
+    if (labels?.length) {
+      payload.tags = labels.map((label) => ({ name: label, displayName: label, displayValue: label }));
+    }
+    const response = await this.post(TASK_ENDPOINTS.CREATE_GENERIC_TASK, payload, { headers });
     const normalizedData = transformData(response.data, TaskMap);
     const transformedData = applyDataTransforms(normalizedData, { field: "status", valueMap: TaskStatusMap });
     return createTaskWithMethods(transformedData, this);
@@ -20855,6 +21653,35 @@ var AssetValueType;
   AssetValueType2["Credential"] = "Credential";
   AssetValueType2["Secret"] = "Secret";
 })(AssetValueType || (AssetValueType = {}));
+async function resolveRefToId(ref, resolvers, callerLabel) {
+  if (!ref) {
+    throw new ValidationError({
+      message: `${callerLabel}: ref must supply exactly one of 'id', 'name', or 'key'.`
+    });
+  }
+  if ("id" in ref && ref.id != null) {
+    return { id: ref.id, effectiveFolder: {} };
+  }
+  const stringVariants = [
+    { variant: "name", resolver: resolvers.byName },
+    { variant: "key", resolver: resolvers.byKey }
+  ];
+  for (const { variant, resolver } of stringVariants) {
+    const value = ref[variant];
+    if (!value)
+      continue;
+    if (!resolver) {
+      throw new ValidationError({
+        message: `${callerLabel}: this method does not support lookup by '${variant}'.`
+      });
+    }
+    const { id, folderId, folderKey, folderPath } = await resolver(value);
+    return { id, effectiveFolder: { folderId, folderKey, folderPath } };
+  }
+  throw new ValidationError({
+    message: `${callerLabel}: ref must supply exactly one of 'id', 'name', or 'key'.`
+  });
+}
 var AssetMap = {
   creationTime: "createdTime",
   lastModificationTime: "lastModifiedTime"
@@ -20893,7 +21720,41 @@ class AssetService extends FolderScopedService {
     return transformedAsset;
   }
   async getByName(name, options = {}) {
-    return this.getByNameLookup("Asset", ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap);
+    const { result } = await this.getByNameLookup("Asset", ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap);
+    return result;
+  }
+  async getByKey(key, options = {}) {
+    const { result } = await this.getByKeyLookup("Asset", ASSET_ENDPOINTS.GET_BY_FOLDER, key, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap);
+    return result;
+  }
+  async updateValue(assetRef, newValue, options) {
+    if (newValue === null || newValue === undefined) {
+      throw new ValidationError({ message: "newValue is required for updateValue" });
+    }
+    let preFetched;
+    const { id, effectiveFolder } = await resolveRefToId(assetRef, {
+      byName: async (name) => {
+        const { result: asset, effectiveFolder: folder } = await this.getByNameLookup("Asset", ASSET_ENDPOINTS.GET_BY_FOLDER, name, { folderId: options?.folderId, folderKey: options?.folderKey, folderPath: options?.folderPath }, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap, "Assets.updateValue");
+        preFetched = asset;
+        return { id: asset.id, ...folder };
+      },
+      byKey: async (key) => {
+        const { result: asset, effectiveFolder: folder } = await this.getByKeyLookup("Asset", ASSET_ENDPOINTS.GET_BY_FOLDER, key, { folderId: options?.folderId, folderKey: options?.folderKey, folderPath: options?.folderPath }, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap), AssetMap, "Assets.updateValue");
+        preFetched = asset;
+        return { id: asset.id, ...folder };
+      }
+    }, "Assets.updateValue");
+    if (id <= 0) {
+      throw new ValidationError({ message: "Assets.updateValue: assetRef.id must be a positive number." });
+    }
+    const headers = resolveFolderHeaders({
+      folderId: effectiveFolder.folderId ?? options?.folderId,
+      folderKey: effectiveFolder.folderKey ?? options?.folderKey,
+      folderPath: effectiveFolder.folderPath ?? options?.folderPath,
+      resourceType: "Assets.updateValue",
+      fallbackFolderKey: this.config.folderKey
+    });
+    await this.updateValueByResolvedId(id, newValue, headers, preFetched);
   }
   async updateValueById(id, newValue, options) {
     if (!id) {
@@ -20909,19 +21770,30 @@ class AssetService extends FolderScopedService {
       resourceType: "Assets.updateValueById",
       fallbackFolderKey: this.config.folderKey
     });
-    const existingResponse = await this.get(ASSET_ENDPOINTS.GET_BY_ID(id), { headers });
-    const existing = existingResponse.data;
-    const valueField = resolveValueField(id, existing.ValueType, newValue);
+    await this.updateValueByResolvedId(id, newValue, headers);
+  }
+  async updateValueByResolvedId(id, newValue, headers, preFetched) {
+    const shape = preFetched ?? await this.fetchAssetShape(id, headers);
+    const valueField = resolveValueField(id, shape.valueType, newValue);
     const body = {
       Id: id,
-      Name: existing.Name,
-      ValueScope: existing.ValueScope,
-      ValueType: existing.ValueType,
-      Description: existing.Description,
+      Name: shape.name,
+      ValueScope: shape.valueScope,
+      ValueType: shape.valueType,
+      Description: shape.description,
       [valueField]: newValue
     };
     await this.put(ASSET_ENDPOINTS.GET_BY_ID(id), body, { headers });
   }
+  async fetchAssetShape(id, headers) {
+    const response = await this.get(ASSET_ENDPOINTS.GET_BY_ID(id), { headers });
+    return {
+      name: response.data.Name,
+      valueScope: response.data.ValueScope,
+      valueType: response.data.ValueType,
+      description: response.data.Description
+    };
+  }
 }
 __decorate([
   track("Assets.GetAll")
@@ -20932,6 +21804,12 @@ __decorate([
 __decorate([
   track("Assets.GetByName")
 ], AssetService.prototype, "getByName", null);
+__decorate([
+  track("Assets.GetByKey")
+], AssetService.prototype, "getByKey", null);
+__decorate([
+  track("Assets.UpdateValue")
+], AssetService.prototype, "updateValue", null);
 __decorate([
   track("Assets.UpdateValueById")
 ], AssetService.prototype, "updateValueById", null);
@@ -20960,7 +21838,7 @@ function resolveValueField(id, valueType, newValue) {
       return "BoolValue";
     default:
       throw new ValidationError({
-        message: `updateValueById only supports Text, Integer, or Bool assets; asset ${id} has valueType ${valueType}`
+        message: `Asset ${id} has valueType ${valueType}; only Text, Integer, and Bool are supported`
       });
   }
 }
@@ -20988,7 +21866,8 @@ class BucketService extends FolderScopedService {
     return pascalToCamelCaseKeys(response.data);
   }
   async getByName(name, options = {}) {
-    return this.getByNameLookup("Bucket", BUCKET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => pascalToCamelCaseKeys(raw));
+    const { result } = await this.getByNameLookup("Bucket", BUCKET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => pascalToCamelCaseKeys(raw));
+    return result;
   }
   async getAll(options) {
     const transformBucketResponse = (bucket) => pascalToCamelCaseKeys(bucket);
@@ -21855,7 +22734,8 @@ class ProcessService extends FolderScopedService {
     return transformedProcess;
   }
   async getByName(name, options = {}) {
-    return this.getByNameLookup("Process", PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap), ProcessMap);
+    const { result } = await this.getByNameLookup("Process", PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap), ProcessMap);
+    return result;
   }
 }
 __decorate([
@@ -21870,21 +22750,112 @@ __decorate([
 __decorate([
   track("Processes.GetByName")
 ], ProcessService.prototype, "getByName", null);
+var QueuePriority;
+(function(QueuePriority2) {
+  QueuePriority2["High"] = "High";
+  QueuePriority2["Normal"] = "Normal";
+  QueuePriority2["Low"] = "Low";
+})(QueuePriority || (QueuePriority = {}));
+var QueueItemStatus;
+(function(QueueItemStatus2) {
+  QueueItemStatus2["New"] = "New";
+  QueueItemStatus2["InProgress"] = "InProgress";
+  QueueItemStatus2["Failed"] = "Failed";
+  QueueItemStatus2["Successful"] = "Successful";
+  QueueItemStatus2["Abandoned"] = "Abandoned";
+  QueueItemStatus2["Retried"] = "Retried";
+  QueueItemStatus2["Deleted"] = "Deleted";
+})(QueueItemStatus || (QueueItemStatus = {}));
+var QueueItemReviewStatus;
+(function(QueueItemReviewStatus2) {
+  QueueItemReviewStatus2["None"] = "None";
+  QueueItemReviewStatus2["InReview"] = "InReview";
+  QueueItemReviewStatus2["Verified"] = "Verified";
+  QueueItemReviewStatus2["Retried"] = "Retried";
+})(QueueItemReviewStatus || (QueueItemReviewStatus = {}));
+var QueueExceptionType;
+(function(QueueExceptionType2) {
+  QueueExceptionType2["ApplicationException"] = "ApplicationException";
+  QueueExceptionType2["BusinessException"] = "BusinessException";
+})(QueueExceptionType || (QueueExceptionType = {}));
+var QueueTransactionOutcome;
+(function(QueueTransactionOutcome2) {
+  QueueTransactionOutcome2["Successful"] = "Successful";
+  QueueTransactionOutcome2["Failed"] = "Failed";
+})(QueueTransactionOutcome || (QueueTransactionOutcome = {}));
+function createQueueMethods(queueData, service) {
+  return {
+    async getAllItems(options) {
+      if (!queueData.id)
+        throw new ValidationError({ message: "Queue ID is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError({ message: "Folder ID is undefined" });
+      return service.getAllItems(queueData.id, { ...options, folderId: queueData.folderId });
+    },
+    async insertItem(specificData, options) {
+      if (!queueData.name)
+        throw new ValidationError({ message: "Queue name is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError({ message: "Folder ID is undefined" });
+      return service.insertItemByName(queueData.name, specificData, { ...options, folderId: queueData.folderId });
+    },
+    async startTransaction() {
+      if (!queueData.name)
+        throw new ValidationError({ message: "Queue name is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError({ message: "Folder ID is undefined" });
+      return service.startTransaction({ name: queueData.name }, { folderId: queueData.folderId });
+    },
+    async completeTransaction(itemId, outcome, options) {
+      if (!queueData.folderId)
+        throw new ValidationError({ message: "Folder ID is undefined" });
+      return service.completeTransaction(itemId, outcome, { ...options, folderId: queueData.folderId });
+    }
+  };
+}
+function createQueueWithMethods(queueData, service) {
+  return Object.assign({}, queueData, createQueueMethods(queueData, service));
+}
 var QueueMap = {
   creationTime: "createdTime",
   organizationUnitId: "folderId",
   organizationUnitFullyQualifiedName: "folderName"
 };
+var QueueItemMap = {
+  queueDefinitionId: "queueId",
+  creationTime: "createdTime",
+  organizationUnitId: "folderId",
+  organizationUnitFullyQualifiedName: "folderName",
+  startProcessing: "processingStartTime",
+  endProcessing: "processingEndTime",
+  processingException: "processingError"
+};
+var QueueItemProcessingErrorMap = {
+  creationTime: "createdTime"
+};
+function transformQueueItem(queueItem) {
+  const { SpecificContent, Output, SpecificData: _sd, OutputData: _od, ...rest } = queueItem;
+  const transformed = transformData(pascalToCamelCaseKeys(rest), QueueItemMap);
+  if (transformed.processingError) {
+    transformed.processingError = transformData(transformed.processingError, QueueItemProcessingErrorMap);
+  }
+  transformed.specificData = SpecificContent ?? null;
+  transformed.outputData = Output ?? null;
+  return transformed;
+}
 class QueueService extends FolderScopedService {
   async getAll(options) {
-    const transformQueueResponse = (queue) => transformData(pascalToCamelCaseKeys(queue), QueueMap);
-    const apiOptions = options ? transformOptions(options, QueueMap) : options;
+    const { folderId, folderKey, folderPath, ...queryOptions } = options ?? {};
+    const hasFolderScope = folderId !== undefined || !!folderKey?.trim() || !!folderPath?.trim();
+    const headers = hasFolderScope ? resolveFolderHeaders({ folderId, folderKey, folderPath, resourceType: "Queues.getAll" }) : undefined;
+    const apiOptions = transformOptions(queryOptions, QueueMap);
     return PaginationHelpers.getAll({
       serviceAccess: this.createPaginationServiceAccess(),
-      getEndpoint: (folderId) => folderId ? QUEUE_ENDPOINTS.GET_BY_FOLDER : QUEUE_ENDPOINTS.GET_ALL,
+      getEndpoint: () => hasFolderScope ? QUEUE_ENDPOINTS.GET_BY_FOLDER : QUEUE_ENDPOINTS.GET_ALL,
       getByFolderEndpoint: QUEUE_ENDPOINTS.GET_BY_FOLDER,
-      transformFn: transformQueueResponse,
+      headers,
+      transformFn: (queue) => createQueueWithMethods(transformData(pascalToCamelCaseKeys(queue), QueueMap), this),
       pagination: {
         paginationType: PaginationType.OFFSET,
         itemsField: ODATA_PAGINATION.ITEMS_FIELD,
@@ -21897,15 +22868,176 @@ class QueueService extends FolderScopedService {
       }
     }, apiOptions);
   }
-  async getById(id, folderId, options = {}) {
-    const headers = createHeaders({ [FOLDER_ID]: folderId });
-    const apiFieldOptions = transformOptions(options, QueueMap);
+  async getById(id, folderIdOrOptions, options = {}) {
+    if (typeof folderIdOrOptions === "number") {
+      const headers2 = createHeaders({ [FOLDER_ID]: folderIdOrOptions });
+      const apiFieldOptions2 = transformOptions(options, QueueMap);
+      const apiOptions2 = addPrefixToKeys(apiFieldOptions2, ODATA_PREFIX, Object.keys(apiFieldOptions2));
+      const response2 = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(id), {
+        headers: headers2,
+        params: apiOptions2
+      });
+      return transformData(pascalToCamelCaseKeys(response2.data), QueueMap);
+    }
+    const { folderId, folderKey, folderPath, ...queryOptions } = folderIdOrOptions ?? {};
+    const headers = resolveFolderHeaders({
+      folderId,
+      folderKey,
+      folderPath,
+      resourceType: "Queues.getById",
+      fallbackFolderKey: this.config.folderKey
+    });
+    const apiFieldOptions = transformOptions(queryOptions, QueueMap);
     const apiOptions = addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions));
     const response = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(id), {
       headers,
       params: apiOptions
     });
-    return transformData(pascalToCamelCaseKeys(response.data), QueueMap);
+    const rawQueue = transformData(pascalToCamelCaseKeys(response.data), QueueMap);
+    return createQueueWithMethods(rawQueue, this);
+  }
+  async getByName(name, options = {}) {
+    const { result } = await this.getByNameLookup("Queue", QUEUE_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => createQueueWithMethods(transformData(pascalToCamelCaseKeys(raw), QueueMap), this), QueueMap);
+    return result;
+  }
+  async getByKey(key, options = {}) {
+    const trimmedKey = key?.trim();
+    if (!trimmedKey || !GUID_REGEX.test(trimmedKey)) {
+      throw new ValidationError({ message: "key must be a GUID for getByKey" });
+    }
+    const { folderId, folderKey, folderPath, ...queryOptions } = options;
+    const headers = resolveFolderHeaders({
+      folderId,
+      folderKey,
+      folderPath,
+      resourceType: "Queues.getByKey",
+      fallbackFolderKey: this.config.folderKey
+    });
+    const apiFieldOptions = transformOptions(queryOptions, QueueMap);
+    const apiOptions = {
+      ...addPrefixToKeys(apiFieldOptions, ODATA_PREFIX, Object.keys(apiFieldOptions)),
+      $filter: `Key eq ${trimmedKey}`,
+      $top: "1"
+    };
+    const response = await this.get(QUEUE_ENDPOINTS.GET_BY_FOLDER, { headers, params: apiOptions });
+    const items = response.data?.value;
+    if (!items?.length) {
+      throw new NotFoundError({ message: `Queue with key '${trimmedKey}' not found.` });
+    }
+    return createQueueWithMethods(transformData(pascalToCamelCaseKeys(items[0]), QueueMap), this);
+  }
+  async getAllItems(queueId, options) {
+    if (!queueId) {
+      throw new ValidationError({ message: "queueId is required for getAllItems" });
+    }
+    const { folderId, folderKey, folderPath, filter, ...restOptions } = options ?? {};
+    const headers = resolveFolderHeaders({
+      folderId,
+      folderKey,
+      folderPath,
+      resourceType: "Queues.getAllItems",
+      fallbackFolderKey: this.config.folderKey
+    });
+    const mergedFilter = filter ? `(${filter}) and queueId eq ${queueId}` : `queueId eq ${queueId}`;
+    const apiOptions = transformOptions({ ...restOptions, filter: mergedFilter }, QueueItemMap);
+    return PaginationHelpers.getAll({
+      serviceAccess: this.createPaginationServiceAccess(),
+      getEndpoint: () => QUEUE_ENDPOINTS.GET_ITEMS,
+      getByFolderEndpoint: QUEUE_ENDPOINTS.GET_ITEMS,
+      headers,
+      transformFn: transformQueueItem,
+      pagination: {
+        paginationType: PaginationType.OFFSET,
+        itemsField: ODATA_PAGINATION.ITEMS_FIELD,
+        totalCountField: ODATA_PAGINATION.TOTAL_COUNT_FIELD,
+        paginationParams: {
+          pageSizeParam: ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+          offsetParam: ODATA_OFFSET_PARAMS.OFFSET_PARAM,
+          countParam: ODATA_OFFSET_PARAMS.COUNT_PARAM
+        }
+      }
+    }, apiOptions);
+  }
+  async insertItemByName(queueName, specificData, options = {}) {
+    if (!queueName) {
+      throw new ValidationError({ message: "queueName is required for insertItemByName" });
+    }
+    const headers = resolveFolderHeaders({
+      folderId: options.folderId,
+      folderKey: options.folderKey,
+      folderPath: options.folderPath,
+      resourceType: "Queues.insertItemByName",
+      fallbackFolderKey: this.config.folderKey
+    });
+    const response = await this.post(QUEUE_ENDPOINTS.ADD_ITEM, {
+      itemData: {
+        Name: queueName,
+        Priority: options.priority ?? QueuePriority.Normal,
+        Reference: options.reference,
+        Progress: options.progress,
+        DeferDate: options.deferDate?.toISOString(),
+        DueDate: options.dueDate?.toISOString(),
+        RiskSlaDate: options.riskSlaDate?.toISOString(),
+        SpecificContent: specificData
+      }
+    }, { headers });
+    return transformQueueItem(response.data);
+  }
+  async startTransaction(queue, options = {}) {
+    const headers = resolveFolderHeaders({
+      folderId: options.folderId,
+      folderKey: options.folderKey,
+      folderPath: options.folderPath,
+      resourceType: "Queues.startTransaction",
+      fallbackFolderKey: this.config.folderKey
+    });
+    let queueName;
+    if (queue?.name) {
+      queueName = queue.name;
+    } else if (queue?.id != null) {
+      queueName = await this.resolveQueueName(queue.id, headers);
+    } else {
+      throw new ValidationError({ message: "queue id or name is required for startTransaction" });
+    }
+    const response = await this.post(QUEUE_ENDPOINTS.START_TRANSACTION, {
+      transactionData: { Name: queueName }
+    }, { headers });
+    if (!response.data || typeof response.data !== "object") {
+      return null;
+    }
+    return transformQueueItem(response.data);
+  }
+  async completeTransaction(itemId, outcome, options = {}) {
+    if (!itemId) {
+      throw new ValidationError({ message: "itemId is required for completeTransaction" });
+    }
+    const headers = resolveFolderHeaders({
+      folderId: options.folderId,
+      folderKey: options.folderKey,
+      folderPath: options.folderPath,
+      resourceType: "Queues.completeTransaction",
+      fallbackFolderKey: this.config.folderKey
+    });
+    const transactionResult = {
+      IsSuccessful: outcome === QueueTransactionOutcome.Successful,
+      ProcessingException: options.processingError && {
+        Reason: options.processingError.reason,
+        Details: options.processingError.details,
+        Type: options.processingError.type,
+        AssociatedImageFilePath: options.processingError.associatedImageFilePath
+      },
+      DeferDate: options.deferDate?.toISOString(),
+      DueDate: options.dueDate?.toISOString(),
+      Progress: options.progress,
+      OperationId: options.operationId,
+      Output: options.outputData,
+      Analytics: options.analytics
+    };
+    await this.post(QUEUE_ENDPOINTS.SET_TRANSACTION_RESULT(itemId), { transactionResult }, { headers });
+  }
+  async resolveQueueName(queueId, headers) {
+    const response = await this.get(QUEUE_ENDPOINTS.GET_BY_ID(queueId), { headers, params: { $select: "Name" } });
+    return response.data.Name;
   }
 }
 __decorate([
@@ -21914,6 +23046,24 @@ __decorate([
 __decorate([
   track("Queues.GetById")
 ], QueueService.prototype, "getById", null);
+__decorate([
+  track("Queues.GetByName")
+], QueueService.prototype, "getByName", null);
+__decorate([
+  track("Queues.GetByKey")
+], QueueService.prototype, "getByKey", null);
+__decorate([
+  track("Queues.GetAllItems")
+], QueueService.prototype, "getAllItems", null);
+__decorate([
+  track("Queues.InsertItemByName")
+], QueueService.prototype, "insertItemByName", null);
+__decorate([
+  track("Queues.StartTransaction")
+], QueueService.prototype, "startTransaction", null);
+__decorate([
+  track("Queues.CompleteTransaction")
+], QueueService.prototype, "completeTransaction", null);
 var TaskCatalogMap = {
   creationTime: "createdTime",
   lastModificationTime: "lastModifiedTime"
@@ -21960,7 +23110,8 @@ class TaskCatalogService extends FolderScopedService {
     return transformData(pascalToCamelCaseKeys(response.data), TaskCatalogMap);
   }
   async getByName(name, options = {}) {
-    return this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
+    const { result } = await this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
+    return result;
   }
   async create(name, options = {}) {
     if (!name) {
@@ -21984,7 +23135,7 @@ class TaskCatalogService extends FolderScopedService {
       throw new ValidationError({ message: "name is required for updateByName" });
     }
     const { folderId, folderKey, folderPath } = options;
-    const current = await this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, { folderId, folderKey, folderPath }, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
+    const { result: current } = await this.getByNameLookup("TaskCatalog", TASK_CATALOG_ENDPOINTS.GET_ALL, name, { folderId, folderKey, folderPath }, (raw) => transformData(pascalToCamelCaseKeys(raw), TaskCatalogMap), TaskCatalogMap);
     return this.update(current, options);
   }
   async update(current, options) {
@@ -22129,6 +23280,13 @@ var AgentMap = {
 var UserSettingsMap = {
   ...CommonFieldMap
 };
+var ConnectionState;
+(function(ConnectionState2) {
+  ConnectionState2["Enabled"] = "Enabled";
+  ConnectionState2["Disabled"] = "Disabled";
+  ConnectionState2["Expired"] = "Expired";
+  ConnectionState2["Failed"] = "Failed";
+})(ConnectionState || (ConnectionState = {}));
 var FeedbackStatus;
 (function(FeedbackStatus2) {
   FeedbackStatus2[FeedbackStatus2["Pending"] = 0] = "Pending";
@@ -23864,7 +25022,7 @@ var ENTITIES_DELETE_EXAMPLES = [
 ];
 var ENTITIES_CREATE_EXAMPLES = [
   {
-    Description: "Create an entity with choice-set, relationship, file, and large-text fields. " + "CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE require 'choiceSetId' (from 'df choice-sets list'). " + "RELATIONSHIP requires 'referenceEntityId' (UUID of the target entity, from 'df entities list') and 'referenceFieldId' (UUID of the field on the target entity, from 'df entities get <target-id>'). " + "Note: a RELATIONSHIP column on a record always stores the target record's UUID 'Id' (regardless of which 'referenceFieldId' configured the join) — see 'df records insert' for how to write the value. " + "FILE fields take only 'name' and 'type' — the server auto-wires the internal attachment reference; populate them later with 'uip df files upload <entity-id> <record-id> <field-name> --file <path>'. " + "MULTILINE_MAX holds very large text ('lengthLimit' = UTF-16 byte budget, 1-131072; default max ~65,536 chars). Not filterable/sortable; 'records list'/'query' return a size marker — full content via 'records get'. Tenant-gated by the 'MultilineMax' feature flag.",
+    Description: "Create an entity with choice-set, relationship, file, and large-text fields. " + "CHOICE_SET_SINGLE/CHOICE_SET_MULTIPLE require 'choiceSetId' (from 'df choice-sets list'). " + "RELATIONSHIP requires 'referenceEntityId' (UUID of the target entity, from 'df entities list') and 'referenceFieldId' (UUID of the field on the target entity, from 'df entities get <target-id>'). " + "Note: a RELATIONSHIP column on a record always stores the target record's UUID 'Id' (regardless of which 'referenceFieldId' configured the join) — see 'df records insert' for how to write the value. " + "FILE fields take only 'name' and 'type' — the server auto-wires the internal attachment reference; populate them later with 'uip df files upload <entity-id> <record-id> <field-name> --file <path>'. " + "MULTILINE_MAX holds very large text ('lengthLimit' = UTF-16 byte budget, 1-131072; default max ~65,536 chars). Not filterable/sortable; 'records list'/'query' return only a preview (content truncated to 10,000 chars with a '...[Truncated]' suffix, or a 'HasValue=true Length=N' marker, depending on the tenant) — full content via 'records get'. Tenant-gated by the 'MultilineMax' feature flag.",
     Command: `uip df entities create Expense --body '{"displayName":"Expense","fields":[{"name":"category","type":"CHOICE_SET_SINGLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000001","isRequired":true},{"name":"tags","type":"CHOICE_SET_MULTIPLE","choiceSetId":"c1d2e3f4-0000-0000-0000-000000000002"},{"name":"submitter","type":"RELATIONSHIP","referenceEntityId":"a1b2c3d4-0000-0000-0000-000000000010","referenceFieldId":"f1000000-0000-0000-0000-000000000100","isRequired":true},{"name":"receipt","type":"FILE"},{"name":"notes","type":"MULTILINE_MAX"}]}'`,
     Output: {
       Code: "EntityCreated",
@@ -24374,7 +25532,7 @@ var registerFilesCommand = (program2) => {
     }
     const fsInst = getFileSystem();
     const fileName = fsInst.path.basename(options.file) || "upload";
-    const [uploadError] = await catchError(sdk.entities.uploadAttachment(entityId, recordId, fieldName, new File([fileContent], fileName), options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
+    const [uploadError] = await catchError(sdk.entities.uploadAttachment({ id: entityId }, recordId, fieldName, new File([fileContent], fileName), options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
     if (uploadError) {
       return fail(`Error uploading file to field '${fieldName}'`, await extractErrorMessage(uploadError));
     }
@@ -24393,7 +25551,7 @@ var registerFilesCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [downloadError, blob] = await catchError(sdk.entities.downloadAttachment(entityId, recordId, fieldName, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
+    const [downloadError, blob] = await catchError(sdk.entities.downloadAttachment({ id: entityId }, recordId, fieldName, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
     if (downloadError) {
       return fail(`Error downloading file from field '${fieldName}'`, await extractErrorMessage(downloadError));
     }
@@ -24424,7 +25582,7 @@ var registerFilesCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [deleteError] = await catchError(sdk.entities.deleteAttachment(entityId, recordId, fieldName, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
+    const [deleteError] = await catchError(sdk.entities.deleteAttachment({ id: entityId }, recordId, fieldName, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
     if (deleteError) {
       return fail(`Error deleting file from field '${fieldName}'`, await extractErrorMessage(deleteError));
     }
@@ -24467,7 +25625,7 @@ async function loadFileFieldNames(sdk, entityId, folderKey) {
 }
 var RECORDS_LIST_EXAMPLES = [
   {
-    Description: "List records in an entity. MULTILINE_MAX fields return a size marker (see 'notes' below) — full value via 'records get'.",
+    Description: "List records in an entity. MULTILINE_MAX fields return only a preview (see 'notes' below): content truncated to 10,000 chars with a '...[Truncated]' suffix, or a 'HasValue=true Length=N' marker, depending on the tenant — full value via 'records get'.",
     Command: "uip df records list a1b2c3d4-0000-0000-0000-000000000001 --limit 2",
     Output: {
       Code: "RecordList",
@@ -24476,7 +25634,7 @@ var RECORDS_LIST_EXAMPLES = [
           {
             Id: "b2c3d4e5-0000-0000-0000-000000000001",
             amount: 1500,
-            notes: "HasValue=true Length=20000"
+            notes: "Expense report for Q3 travel...[Truncated]"
           },
           {
             Id: "b2c3d4e5-0000-0000-0000-000000000002",
@@ -24665,7 +25823,7 @@ var registerRecordsCommand = (program2) => {
     if (fileErr)
       return fail(fileErr.message, fileErr.instructions);
     if (recordsList.length === 1) {
-      const [insertError, result] = await catchError(sdk.entities.insertRecordById(entityId, recordsList[0], folderOptions));
+      const [insertError, result] = await catchError(sdk.entities.insertRecord({ id: entityId }, recordsList[0], folderOptions));
       if (insertError) {
         return fail("Error inserting record", await extractErrorMessage(insertError));
       }
@@ -24675,7 +25833,7 @@ var registerRecordsCommand = (program2) => {
         Data: result
       });
     } else {
-      const [insertError, result] = await catchError(sdk.entities.insertRecordsById(entityId, recordsList, folderOptions));
+      const [insertError, result] = await catchError(sdk.entities.insertRecords({ id: entityId }, recordsList, folderOptions));
       if (insertError) {
         return fail("Error inserting records", await extractErrorMessage(insertError));
       }
@@ -24717,7 +25875,7 @@ var registerRecordsCommand = (program2) => {
       if (recordId === undefined || recordId === null) {
         return fail("Record must include an 'Id' field", "Provide the record ID in the JSON data.");
       }
-      const [updateError, result] = await catchError(sdk.entities.updateRecordById(entityId, String(recordId), record, folderOptions));
+      const [updateError, result] = await catchError(sdk.entities.updateRecord({ id: entityId }, String(recordId), record, folderOptions));
       if (updateError) {
         return fail("Error updating record", await extractErrorMessage(updateError));
       }
@@ -24731,7 +25889,7 @@ var registerRecordsCommand = (program2) => {
       if (missingId) {
         return fail("All records must include an 'Id' field", "Provide the record ID in each JSON object.");
       }
-      const [updateError, result] = await catchError(sdk.entities.updateRecordsById(entityId, recordsList, folderOptions));
+      const [updateError, result] = await catchError(sdk.entities.updateRecords({ id: entityId }, recordsList, folderOptions));
       if (updateError) {
         return fail("Error updating records", await extractErrorMessage(updateError));
       }
@@ -24789,7 +25947,7 @@ var registerRecordsCommand = (program2) => {
     if (!sdk)
       return;
     const queryPaginationOptions = options.cursor !== undefined ? { pageSize, cursor: { value: options.cursor } } : jumpToPage !== undefined ? { pageSize, jumpToPage } : { pageSize };
-    const [queryError, result] = await catchError(sdk.entities.queryRecordsById(entityId, {
+    const [queryError, result] = await catchError(sdk.entities.queryRecords({ id: entityId }, {
       ...queryBody !== null && queryBody,
       ...queryPaginationOptions,
       ...options.folderKey !== undefined && {
@@ -24819,7 +25977,7 @@ var registerRecordsCommand = (program2) => {
     const fs2 = getFileSystem();
     const fileName = fs2.path.basename(options.file) || "import.csv";
     const csvFile = new File([fileContent], fileName, { type: "text/csv" });
-    const [importError, result] = await catchError(sdk.entities.importRecordsById(entityId, csvFile, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
+    const [importError, result] = await catchError(sdk.entities.importRecords({ id: entityId }, csvFile, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
     if (importError) {
       return fail("Error importing records", await extractErrorMessage(importError));
     }
@@ -24843,7 +26001,7 @@ var registerRecordsCommand = (program2) => {
     const sdk = await connectOrFail(options.tenant);
     if (!sdk)
       return;
-    const [deleteError, result] = await catchError(sdk.entities.deleteRecordsById(entityId, recordIds, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
+    const [deleteError, result] = await catchError(sdk.entities.deleteRecords({ id: entityId }, recordIds, options.folderKey !== undefined ? { folderKey: options.folderKey } : undefined));
     if (deleteError) {
       return fail("Error deleting records", await extractErrorMessage(deleteError));
     }
@@ -24935,4 +26093,4 @@ var registerCommands = async (program2) => {
 export { Command, metadata, registerCommands };
-//# debugId=07DCFCD8FD86D2D164756E2164756E21
+//# debugId=7C4D0D556CB51E1764756E2164756E21