@uipath/vertical-solutions-tool 1.202.0 → 1.203.0-preview.160

package/dist/{tool-wzespwbb.js → tool-1jrjdzgz.js}

@@ -6863,8 +6863,9 @@ var require_src6 = __commonJS(function(exports) {
 // package.json
 var package_default = {
   name: "@uipath/vertical-solutions-tool",
+  author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.202.0",
+  version: "1.203.0-preview.160",
   description: "Scaffold and generate Vertical Solution projects.",
   private: false,
   repository: {
@@ -6909,7 +6910,7 @@ var package_default = {
     "@uipath/auth": "workspace:*",
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/uipath-typescript": "^1.6.1",
+    "@uipath/uipath-typescript": "^1.7.1",
     "@inquirer/prompts": "^8.3.2",
     "@types/node": "^25.5.2",
     commander: "^14.0.3",
@@ -7431,7 +7432,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;
@@ -7478,7 +7479,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;
@@ -7493,10 +7494,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 {
@@ -8198,7 +8202,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 "";
@@ -8880,28 +8885,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)
@@ -9005,6 +9014,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;
@@ -9029,6 +9041,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 ?? "");
 }
@@ -9044,7 +9060,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);
@@ -9066,7 +9082,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);
@@ -9097,7 +9113,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) {
@@ -9171,6 +9187,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) {
@@ -31426,16 +31656,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 env2 = {};
   for (const line of content.split(`
 `)) {
@@ -31456,6 +31677,18 @@ var loadEnvFileAsync = async ({ envPath }) => {
   }
   return env2;
 };
+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,
@@ -32437,7 +32670,7 @@ var allowsEval2 = cached2(() => {
     return false;
   }
 });
-function isPlainObject4(o) {
+function isPlainObject$1(o) {
   if (isObject2(o) === false)
     return false;
   const ctor = o.constructor;
@@ -32454,7 +32687,7 @@ function isPlainObject4(o) {
   return true;
 }
 function shallowClone2(o) {
-  if (isPlainObject4(o))
+  if (isPlainObject$1(o))
     return { ...o };
   if (Array.isArray(o))
     return [...o];
@@ -32542,7 +32775,7 @@ function omit2(schema, mask) {
   return clone2(schema, def);
 }
 function extend2(schema, shape) {
-  if (!isPlainObject4(shape)) {
+  if (!isPlainObject$1(shape)) {
     throw new Error("Invalid input to extend: expected a plain object");
   }
   const checks3 = schema._zod.def.checks;
@@ -32565,7 +32798,7 @@ function extend2(schema, shape) {
   return clone2(schema, def);
 }
 function safeExtend2(schema, shape) {
-  if (!isPlainObject4(shape)) {
+  if (!isPlainObject$1(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
   const def = mergeDefs2(schema._zod.def, {
@@ -32902,6 +33135,7 @@ var string$1 = (params) => {
   const regex2 = params ? `[\\s\\S]{${params?.minimum ?? 0},${params?.maximum ?? ""}}` : `[\\s\\S]*`;
   return new RegExp(`^${regex2}$`);
 };
+var boolean$1 = /^(?:true|false)$/i;
 var lowercase2 = /^[^A-Z]*$/;
 var uppercase2 = /^[^a-z]*$/;
 var $ZodCheck2 = /* @__PURE__ */ $constructor2("$ZodCheck", (inst, def) => {
@@ -33570,6 +33804,26 @@ var $ZodJWT2 = /* @__PURE__ */ $constructor2("$ZodJWT", (inst, def) => {
     });
   };
 });
+var $ZodBoolean2 = /* @__PURE__ */ $constructor2("$ZodBoolean", (inst, def) => {
+  $ZodType2.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 $ZodUnknown2 = /* @__PURE__ */ $constructor2("$ZodUnknown", (inst, def) => {
   $ZodType2.init(inst, def);
   inst._zod.parse = (payload) => payload;
@@ -33940,7 +34194,7 @@ function mergeValues2(a, b) {
   if (a instanceof Date && b instanceof Date && +a === +b) {
     return { valid: true, data: a };
   }
-  if (isPlainObject4(a) && isPlainObject4(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 };
@@ -34295,7 +34549,7 @@ function handleRefineResult2(result, payload, input, inst) {
     payload.issues.push(issue2(_iss));
   }
 }
-var _a3;
+var _a$1;
 
 class $ZodRegistry2 {
   constructor() {
@@ -34340,7 +34594,7 @@ class $ZodRegistry2 {
 function registry3() {
   return new $ZodRegistry2;
 }
-(_a3 = globalThis).__zod_globalRegistry ?? (_a3.__zod_globalRegistry = registry3());
+(_a$1 = globalThis).__zod_globalRegistry ?? (_a$1.__zod_globalRegistry = registry3());
 var globalRegistry2 = globalThis.__zod_globalRegistry;
 function _string2(Class2, params) {
   return new Class2({
@@ -34585,6 +34839,12 @@ function _isoDuration2(Class2, params) {
     ...normalizeParams2(params)
   });
 }
+function _boolean2(Class2, params) {
+  return new Class2({
+    type: "boolean",
+    ...normalizeParams2(params)
+  });
+}
 function _unknown2(Class2) {
   return new Class2({
     type: "unknown"
@@ -34750,7 +35010,7 @@ function initializeContext2(params) {
   };
 }
 function process13(schema, ctx, _params = { path: [], schemaPath: [] }) {
-  var _a4;
+  var _a3;
   const def = schema._zod.def;
   const seen = ctx.seen.get(schema);
   if (seen) {
@@ -34798,7 +35058,7 @@ function process13(schema, ctx, _params = { path: [], schemaPath: [] }) {
     delete result.schema.default;
   }
   if (ctx.io === "input" && result.schema._prefault)
-    (_a4 = result.schema).default ?? (_a4.default = result.schema._prefault);
+    (_a3 = result.schema).default ?? (_a3.default = result.schema._prefault);
   delete result.schema._prefault;
   const _result = ctx.seen.get(schema);
   return _result.schema;
@@ -35115,6 +35375,9 @@ var stringProcessor2 = (schema, ctx, _json, _params) => {
     }
   }
 };
+var booleanProcessor2 = (_schema, _ctx, json2, _params) => {
+  json2.type = "boolean";
+};
 var neverProcessor2 = (_schema, _ctx, json2, _params) => {
   json2.not = {};
 };
@@ -35573,6 +35836,14 @@ var ZodJWT2 = /* @__PURE__ */ $constructor2("ZodJWT", (inst, def) => {
   $ZodJWT2.init(inst, def);
   ZodStringFormat2.init(inst, def);
 });
+var ZodBoolean2 = /* @__PURE__ */ $constructor2("ZodBoolean", (inst, def) => {
+  $ZodBoolean2.init(inst, def);
+  ZodType2.init(inst, def);
+  inst._zod.processJSONSchema = (ctx, json2, params) => booleanProcessor2(inst, ctx, json2);
+});
+function boolean4(params) {
+  return _boolean2(ZodBoolean2, params);
+}
 var ZodUnknown2 = /* @__PURE__ */ $constructor2("ZodUnknown", (inst, def) => {
   $ZodUnknown2.init(inst, def);
   ZodType2.init(inst, def);
@@ -35883,7 +36154,8 @@ object2({
   secret: string4().optional(),
   clientId: string4().optional(),
   redirectUri: string4().url().optional(),
-  scope: string4().optional()
+  scope: string4().optional(),
+  enforceSso: boolean4().optional()
 });
 
 class UiPathConfig {
@@ -35895,6 +36167,7 @@ class UiPathConfig {
     this.clientId = options.clientId;
     this.redirectUri = options.redirectUri;
     this.scope = options.scope;
+    this.enforceSso = options.enforceSso;
   }
 }
 
@@ -36097,6 +36370,7 @@ var TaskType;
   TaskType2["DocumentValidation"] = "DocumentValidationTask";
   TaskType2["DocumentClassification"] = "DocumentClassificationTask";
   TaskType2["DataLabeling"] = "DataLabelingTask";
+  TaskType2["QuickForm"] = "QuickFormTask";
 })(TaskType || (TaskType = {}));
 var TaskPriority;
 (function(TaskPriority2) {
@@ -36209,7 +36483,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`,
@@ -36256,6 +36534,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}`,
@@ -36290,13 +36572,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`,
@@ -36319,7 +36612,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,
@@ -36327,7 +36621,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) {
@@ -36335,29 +36630,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) => {
@@ -36426,12 +36704,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: promise2 } = requestHostToken({
       pinnedOrigin: parentOrigin,
       sendRequest: () => this.sendMessageToParent(ActionCenterEventNames.REFRESHTOKEN, {
@@ -36455,7 +36727,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 (error52) {
@@ -36535,7 +36807,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";
@@ -36601,19 +36873,21 @@ function base64UrlToBase64(value) {
   const base644 = value.replace(BASE64URL_DASH_RE, "+").replace(BASE64URL_UNDERSCORE_RE, "/");
   return base644.padEnd(base644.length + (4 - base644.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, config3, isOAuth = false) {
@@ -36626,8 +36900,8 @@ class TokenManager {
     if (isInActionCenter) {
       this.actionCenterTokenManager = new ActionCenterTokenManager(config3, (tokenInfo) => this.setToken(tokenInfo));
       this.isOAuth = false;
-    } else if (trustedEmbeddingOrigin) {
-      this.embeddedTokenManager = new EmbeddedTokenManager(trustedEmbeddingOrigin, config3, (tokenInfo) => this.setToken(tokenInfo));
+    } else if (hostEmbeddingOrigin) {
+      this.embeddedTokenManager = new EmbeddedTokenManager(hostEmbeddingOrigin, config3, (tokenInfo) => this.setToken(tokenInfo));
       this.isOAuth = false;
     }
   }
@@ -36738,6 +37012,9 @@ class TokenManager {
   getToken() {
     return this.currentToken?.token;
   }
+  getIdToken() {
+    return this.currentToken?.idToken;
+  }
   hasValidToken() {
     if (!this.currentToken) {
       return false;
@@ -36809,11 +37086,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(config3, executionContext) {
@@ -36947,7 +37226,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 {
@@ -36957,6 +37240,12 @@ class AuthService {
         console.warn("Failed to clear OAuth context from session storage", error52);
       }
     }
+    if (options?.endSession && isBrowser2 && idTokenHint) {
+      window.location.href = this._buildEndSessionUrl({
+        idTokenHint,
+        postLogoutRedirectUri: this.config.redirectUri
+      });
+    }
   }
   getToken() {
     if (!this.tokenManager.hasValidToken()) {
@@ -37000,10 +37289,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({
@@ -37030,7 +37336,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;
   }
@@ -37103,9 +37410,18 @@ function validateConfig(config3) {
 function isCompleteConfig(config3) {
   return hasRequiredBaseFields(config3) && hasValidAuthConfig(config3);
 }
+function compactConfig(config3) {
+  return Object.fromEntries(Object.entries(config3).filter(([, value]) => value !== undefined));
+}
 function normalizeBaseUrl2(url2) {
   return url2.endsWith("/") ? url2.slice(0, -1) : url2;
 }
+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;
@@ -37114,6 +37430,7 @@ var getGlobalStore = () => {
   }
   return globalObj[REGISTRY_KEY2];
 };
+var looksLikeUiPath = (instance) => typeof instance.initialize === "function";
 
 class SDKInternalsRegistry {
   static get store() {
@@ -37125,6 +37442,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;
@@ -37142,6 +37462,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;
@@ -37162,7 +37486,54 @@ function loadFromMetaTags() {
   const hasAnyValue = Object.values(config3).some(Boolean);
   return hasAnyValue ? config3 : 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 config3 = {
+    baseUrl: readEnv(UiPathEnvVars.BASE_URL),
+    orgName: readEnv(UiPathEnvVars.ORG_NAME),
+    tenantName: readEnv(UiPathEnvVars.TENANT_NAME),
+    secret: readEnv(UiPathEnvVars.ACCESS_TOKEN)
+  };
+  return Object.values(config3).some(Boolean) ? config3 : null;
+}
+function isFunctionContext(value) {
+  return "platform" in value || "robot" in value;
+}
+function configFromFunctionContext(context) {
+  const { platform, robot } = context;
+  if (!platform)
+    return null;
+  const config3 = {
+    baseUrl: platform.baseUrl,
+    orgName: platform.orgId,
+    tenantName: platform.tenantId,
+    secret: robot?.accessToken ?? undefined
+  };
+  return Object.values(config3).some(Boolean) ? config3 : null;
+}
 var _UiPath_instances;
+var _a3;
 var _UiPath_config;
 var _UiPath_authService;
 var _UiPath_initialized;
@@ -37171,6 +37542,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(config3) {
@@ -37182,15 +37554,16 @@ var UiPath$1 = class UiPath {
     _UiPath_metaFolderKey.set(this, undefined);
     _UiPath_metaOrgId.set(this, undefined);
     _UiPath_metaTenantId.set(this, undefined);
+    const resolved = config3 && isFunctionContext(config3) ? configFromFunctionContext(config3) ?? undefined : config3;
     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 = config3 ? { ...configFromMetaTags, ...config3 } : configFromMetaTags;
+    const mergedConfig = __classPrivateFieldGet(_a3, _a3, "m", _UiPath_mergeConfigSources).call(_a3, configFromMetaTags, resolved);
     if (mergedConfig && isCompleteConfig(mergedConfig)) {
       __classPrivateFieldGet(this, _UiPath_instances, "m", _UiPath_initializeWithConfig).call(this, mergedConfig);
-    } else if (config3) {
-      __classPrivateFieldSet(this, _UiPath_partialConfig, config3, "f");
+    } else if (resolved) {
+      __classPrivateFieldSet(this, _UiPath_partialConfig, resolved, "f");
     }
   }
   async initialize() {
@@ -37255,18 +37628,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(config3) {
+_a3 = 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(config3) {
   validateConfig(config3);
   const hasSecretAuth = hasSecretConfig(config3);
   const hasOAuthAuth = hasOAuthConfig(config3);
@@ -37277,7 +37650,8 @@ _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initial
     secret: hasSecretAuth ? config3.secret : undefined,
     clientId: hasOAuthAuth ? config3.clientId : undefined,
     redirectUri: hasOAuthAuth ? config3.redirectUri : undefined,
-    scope: hasOAuthAuth ? config3.scope : undefined
+    scope: hasOAuthAuth ? config3.scope : undefined,
+    enforceSso: config3.enforceSso
   });
   const executionContext = new ExecutionContext;
   __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
@@ -37303,18 +37677,35 @@ _UiPath_config = new WeakMap, _UiPath_authService = new WeakMap, _UiPath_initial
     redirectUri: hasOAuthAuth ? config3.redirectUri : undefined
   });
   trackEvent("Sdk.Auth");
-  if (hasSecretAuth || isInActionCenter || trustedEmbeddingOrigin) {
+  if (hasSecretAuth || isInActionCenter || hostEmbeddingOrigin) {
     __classPrivateFieldGet(this, _UiPath_authService, "f").authenticateWithSecret(config3.secret ?? "");
     __classPrivateFieldSet(this, _UiPath_initialized, true, "f");
   }
+}, _UiPath_mergeConfigSources = function _UiPath_mergeConfigSources2(metaConfig, config3) {
+  const layers = [loadFromEnvironment(), metaConfig, config3].filter((layer) => Boolean(layer)).map((layer) => compactConfig(layer));
+  if (layers.length === 0)
+    return;
+  const merged = layers.reduce((acc, layer) => ({ ...acc, ...layer }), {});
+  const namesSecret = config3 ? hasSecretConfig(config3) : false;
+  const namesOAuth = Boolean(config3?.clientId || config3?.redirectUri || config3?.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(_a3, _a3, "m", _UiPath_mergeConfigSources).call(_a3, metaConfig, __classPrivateFieldGet(this, _UiPath_partialConfig, "f"));
+  if (!merged || !isCompleteConfig(merged)) {
+    throw new Error(missingConfigMessage());
   }
   return merged;
 };
@@ -37492,8 +37883,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 date6 = Date.parse(trimmed);
+  if (Number.isNaN(date6))
+    return;
+  return Math.max(0, date6 - now);
+}
+function wait(durationMs) {
+  return new Promise((resolve2) => setTimeout(resolve2, Math.max(0, durationMs)));
+}
+var RETRY_AFTER = "retry-after";
+function createAttemptSignal(timeoutMs, external2) {
+  if (timeoutMs === undefined || !Number.isFinite(timeoutMs))
+    return { signal: external2, dispose: () => {} };
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(new Error(`Request timeout after ${timeoutMs}ms`)), timeoutMs);
+  const onExternalAbort = () => controller.abort(external2?.reason);
+  if (external2) {
+    if (external2.aborted) {
+      controller.abort(external2.reason);
+    } else {
+      external2.addEventListener("abort", onExternalAbort);
+    }
+  }
+  return {
+    signal: controller.signal,
+    dispose: () => {
+      clearTimeout(timer);
+      external2?.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(url2, 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(url2, { ...init, signal });
+    } catch (error52) {
+      failure = error52;
+    } 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((error52) => {
+      console.warn("[UiPath SDK] Could not release a discarded response body:", error52);
+    });
+    await delayBeforeRetry(delay, options.signal);
+    attempt++;
+  }
+}
 
 class ApiClient {
   constructor(config3, executionContext, tokenManager, clientConfig = {}) {
@@ -37528,28 +38088,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() ? `${url2}?${searchParams.toString()}` : url2;
     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);
@@ -38265,36 +38813,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)
@@ -38311,27 +38859,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, file2, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.uploadAttachment(entityData.id, recordId, fieldName, file2, options);
+      return service.uploadAttachment({ id: entityData.id }, recordId, fieldName, file2, 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(file2, options) {
       if (!entityData.id)
         throw new Error("Entity ID is undefined");
-      return service.importRecordsById(entityData.id, file2, options);
+      return service.importRecords({ id: entityData.id }, file2, options);
     },
     async insert(data, options) {
       return this.insertRecord(data, options);
@@ -38407,6 +38955,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";
@@ -38437,15 +38994,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";
@@ -38584,95 +39132,84 @@ function toWireJoin(join2, baseEntityName) {
     }
   };
 }
+function unwrapEntityRef(entityRef, callerLabel) {
+  const { id, name } = entityRef ?? {};
+  if (id && name) {
+    throw new ValidationError3({
+      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 ValidationError3({
+    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;
@@ -38684,62 +39221,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 ValidationError3({
-        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 ValidationError3({
-        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, file2, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.importRecords");
+    return this.importRecordsImpl(byId, identifier, file2, options);
   }
   async importRecordsById(id, file2, options) {
-    const formData = new FormData;
-    if (file2 instanceof Uint8Array) {
-      formData.append("file", new Blob([file2.buffer]));
-    } else {
-      formData.append("file", file2);
-    }
-    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, file2, 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, file2, options) {
+  async uploadAttachment(entityRef, recordId, fieldName, file2, options) {
+    const { byId, identifier } = unwrapEntityRef(entityRef, "Entities.uploadAttachment");
     const formData = new FormData;
     if (file2 instanceof Uint8Array) {
       formData.append("file", new Blob([file2.buffer]));
@@ -38747,14 +39252,15 @@ class EntityService extends BaseService {
       formData.append("file", file2);
     }
     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) {
@@ -38791,11 +39297,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 ValidationError3({
+        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 }
@@ -38808,10 +39319,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 ValidationError3({
+          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 ValidationError3({
+          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 ?? "");
@@ -39061,40 +39586,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 ValidationError3({
+        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 ValidationError3({
+        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 ValidationError3({
+        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, file2, options) {
+    const formData = new FormData;
+    if (file2 instanceof Uint8Array) {
+      formData.append("file", new Blob([file2.buffer]));
+    } else {
+      formData.append("file", file2);
+    }
+    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);
@@ -40538,6 +41208,74 @@ function validateName(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 isPlainObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asResourceOverrides(value) {
+  if (!isPlainObject4(value))
+    return;
+  const table = {};
+  for (const [key, properties] of Object.entries(value)) {
+    if (!isPlainObject4(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 (error52) {
+    console.warn(`[UiPath SDK] Failed to parse <script id="${UiPathElementIds.RESOURCE_OVERRIDES}"> as JSON — proceeding without overrides:`, error52);
+    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 (error52) {
+    console.warn("[UiPath SDK] Override source threw — proceeding without overrides:", error52);
+    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 {
@@ -40554,20 +41292,23 @@ class FolderScopedService extends BaseService {
     }
     return response.data?.value;
   }
-  async getByNameLookup(resourceType, endpoint, name, options, transform3, responseFieldMap) {
+  async getByNameLookup(resourceType, endpoint, name, options, transform3, responseFieldMap, callerLabel) {
     const validatedName = validateName(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, {
@@ -40576,12 +41317,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 transform3(items[0]);
+    return {
+      result: transform3(items[0]),
+      effectiveFolder: { folderId, folderKey, folderPath: resolvedFolderPath }
+    };
+  }
+  async getByKeyLookup(resourceType, endpoint, key, options, transform3, responseFieldMap, callerLabel) {
+    const label = callerLabel ?? `${resourceType}.getByKey`;
+    const trimmedKey = key?.trim();
+    if (!trimmedKey || !GUID_REGEX.test(trimmedKey)) {
+      throw new ValidationError3({ 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: transform3(items[0]),
+      effectiveFolder: { folderId, folderKey, folderPath }
+    };
   }
 }
 function describeFolderForError(folderId, folderKey, folderPath) {
@@ -40612,12 +41389,16 @@ class TaskService extends FolderScopedService {
     };
   }
   async create(task, folderId) {
+    if (task.type === TaskType.QuickForm && !task.taskSchemaKey) {
+      throw new ValidationError3({ 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);
@@ -41249,6 +42030,35 @@ var AssetValueType;
   AssetValueType2["Credential"] = "Credential";
   AssetValueType2["Secret"] = "Secret";
 })(AssetValueType || (AssetValueType = {}));
+async function resolveRefToId(ref, resolvers, callerLabel) {
+  if (!ref) {
+    throw new ValidationError3({
+      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 ValidationError3({
+        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 ValidationError3({
+    message: `${callerLabel}: ref must supply exactly one of 'id', 'name', or 'key'.`
+  });
+}
 var AssetMap = {
   creationTime: "createdTime",
   lastModificationTime: "lastModifiedTime"
@@ -41287,7 +42097,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 ValidationError3({ 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 ValidationError3({ 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) {
@@ -41303,19 +42147,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")
@@ -41326,6 +42181,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);
@@ -41354,7 +42215,7 @@ function resolveValueField(id, valueType, newValue) {
       return "BoolValue";
     default:
       throw new ValidationError3({
-        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`
       });
   }
 }
@@ -41382,7 +42243,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);
@@ -42249,7 +43111,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([
@@ -42264,21 +43127,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 ValidationError3({ message: "Queue ID is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError3({ message: "Folder ID is undefined" });
+      return service.getAllItems(queueData.id, { ...options, folderId: queueData.folderId });
+    },
+    async insertItem(specificData, options) {
+      if (!queueData.name)
+        throw new ValidationError3({ message: "Queue name is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError3({ message: "Folder ID is undefined" });
+      return service.insertItemByName(queueData.name, specificData, { ...options, folderId: queueData.folderId });
+    },
+    async startTransaction() {
+      if (!queueData.name)
+        throw new ValidationError3({ message: "Queue name is undefined" });
+      if (!queueData.folderId)
+        throw new ValidationError3({ message: "Folder ID is undefined" });
+      return service.startTransaction({ name: queueData.name }, { folderId: queueData.folderId });
+    },
+    async completeTransaction(itemId, outcome, options) {
+      if (!queueData.folderId)
+        throw new ValidationError3({ 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,
@@ -42291,15 +43245,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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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 ValidationError3({ 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([
@@ -42308,6 +43423,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"
@@ -42354,7 +43487,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) {
@@ -42378,7 +43512,7 @@ class TaskCatalogService extends FolderScopedService {
       throw new ValidationError3({ 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) {
@@ -42523,6 +43657,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";
@@ -43409,4 +44550,4 @@ var registerCommands = async (program2) => {
 
 export { Command, metadata, registerCommands };
 
-//# debugId=AA8CC418A164893E64756E2164756E21
+//# debugId=C52E7100F1D99EB864756E2164756E21