@uipath/insights-sdk 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/index.browser.js

@@ -275,11 +275,25 @@ function settlePromiseLike(thenable) {
 }
 
 // src/errors.ts
+var MODEL_NOT_FOUND_LABEL = "Model not found";
+var DASHBOARD_NOT_FOUND_LABEL = "Dashboard not found";
+var VALIDATION_FAILED_LABEL = "Validation failed";
+var CREATE_BACKEND_FAILURE_LABEL = "Failed to create dashboard";
+var UPDATE_BACKEND_FAILURE_LABEL = "Failed to update dashboard";
+var KNOWN_ERROR_LABELS = new Set([
+  VALIDATION_FAILED_LABEL,
+  CREATE_BACKEND_FAILURE_LABEL,
+  UPDATE_BACKEND_FAILURE_LABEL,
+  DASHBOARD_NOT_FOUND_LABEL,
+  MODEL_NOT_FOUND_LABEL
+]);
+
 class InsightsHttpError extends Error {
   status;
   method;
   endpoint;
   bodyKind;
+  bodyHint;
   requestId;
   retryAfterSeconds;
   constructor(init) {
@@ -289,6 +303,7 @@ class InsightsHttpError extends Error {
     this.method = init.method;
     this.endpoint = init.endpoint;
     this.bodyKind = init.bodyKind;
+    this.bodyHint = init.bodyHint;
     this.requestId = init.requestId;
     this.retryAfterSeconds = init.retryAfterSeconds;
   }
@@ -296,10 +311,12 @@ class InsightsHttpError extends Error {
 
 class InsightsNetworkError extends Error {
   endpoint;
+  phase;
   constructor(endpoint, cause, phase = "request") {
     super(phase === "request" ? `Insights request failed before a response was received for ${endpoint}` : `Insights connection failed while reading the response body for ${endpoint}`, { cause });
     this.name = "InsightsNetworkError";
     this.endpoint = endpoint;
+    this.phase = phase;
   }
 }
 
@@ -315,7 +332,136 @@ class InsightsProtocolError extends Error {
 // ../common/src/telemetry/global-telemetry-properties.ts
 var telemetryPropsSlot = singleton("TelemetryDefaultProps");
 
+// ../common/src/telemetry/telemetry-dimensions.ts
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions)
+]);
+
 // ../common/src/sdk-user-agent.ts
+var AGENT_PROPERTY = BaseDimensions.Agent;
 var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 function splitUserAgentTokens(value) {
   return value?.trim().split(/\s+/).filter(Boolean) ?? [];
@@ -343,7 +489,7 @@ var package_default = {
   name: "@uipath/insights-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0-preview.212",
+  version: "1.204.0-preview.211",
   description: "SDK for the UiPath Insights API — jobs, failures, and performance metrics.",
   repository: {
     type: "git",
@@ -431,7 +577,8 @@ var INSIGHTS_ROUTES = {
   alertDefinitionsSnooze: {
     service: "rtm",
     method: "PUT",
-    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}/{accountName}/{tenantName}/snooze?isSnoozed={isSnoozed}"
+    template: "AlertDefinitions/{tenantId}/{alertDefinitionId}/{accountName}/{tenantName}/snooze",
+    queryParams: ["isSnoozed"]
   },
   alertDefinitionsDelete: {
     service: "rtm",
@@ -479,6 +626,59 @@ var INSIGHTS_ROUTES = {
     method: "POST",
     template: "Filters/allMachines"
   },
+  dashboardsGet: {
+    service: "rtm",
+    method: "GET",
+    template: "api/v1.0/standalone-dashboard/{sourceType}/{dashboardId}",
+    identityHeaders: "ids",
+    queryParams: ["localization"]
+  },
+  dashboardFiltersList: {
+    service: "rtm",
+    method: "GET",
+    template: "api/v1.0/standalone-dashboard/{sourceType}/{dashboardId}/filters",
+    identityHeaders: "ids"
+  },
+  dashboardTemplatesGet: {
+    service: "rtm",
+    method: "GET",
+    template: "api/v1.0/standalone-dashboard/{sourceType}/template",
+    queryParams: [
+      "tenantId",
+      "organizationId",
+      "serviceIdentifier",
+      "localization"
+    ]
+  },
+  dashboardsCreate: {
+    service: "rtm",
+    method: "POST",
+    template: "api/v1.0/standalone-dashboard/{sourceType}",
+    identityHeaders: "tenant-id",
+    queryParams: ["organizationId", "serviceIdentifier"]
+  },
+  dashboardsUpdate: {
+    service: "rtm",
+    method: "PUT",
+    template: "api/v1.0/standalone-dashboard/{sourceType}/{dashboardId}",
+    identityHeaders: "ids"
+  },
+  dashboardsDelete: {
+    service: "rtm",
+    method: "DELETE",
+    template: "api/v1.0/standalone-dashboard/{sourceType}/{dashboardId}",
+    identityHeaders: "ids"
+  },
+  queuesQuery: {
+    service: "rtm",
+    method: "POST",
+    template: "Queues/{accountName}/{tenantName}"
+  },
+  machinesQuery: {
+    service: "rtm",
+    method: "POST",
+    template: "Machines"
+  },
   usersList: { service: "portal", method: "GET", template: "User" },
   usersGet: { service: "portal", method: "GET", template: "User/{userId}" },
   rolesList: { service: "portal", method: "GET", template: "Role" },
@@ -493,12 +693,31 @@ var INSIGHTS_ROUTES = {
     service: "portal",
     method: "POST",
     template: "Authorization/tenant/insights"
+  },
+  exportConfigurationsList: {
+    service: "portal",
+    method: "GET",
+    template: "unifiedexport/configuration"
+  },
+  exportDestinationsVerifyAll: {
+    service: "portal",
+    method: "POST",
+    template: "unifiedexport/destination/verify/all"
+  },
+  exportDestinationVerify: {
+    service: "portal",
+    method: "POST",
+    template: "unifiedexport/destination/{configurationId}/verify"
   }
 };
 function insightsRouteTemplate(routeKey) {
   return INSIGHTS_ROUTES[routeKey].template;
 }
-var SESSION_PARAM_NAMES = new Set(["tenantId", "accountName", "tenantName"]);
+var SESSION_PATH_PARAM_NAMES = new Set([
+  "tenantId",
+  "accountName",
+  "tenantName"
+]);
 function sessionPathParams(config) {
   return {
     tenantId: config.tenantId,
@@ -506,6 +725,13 @@ function sessionPathParams(config) {
     tenantName: config.tenantName
   };
 }
+var SESSION_QUERY_PARAM_NAMES = new Set(["tenantId", "organizationId"]);
+function sessionQueryParams(config) {
+  return {
+    tenantId: config.tenantId,
+    organizationId: config.organizationId
+  };
+}
 function encodePathSegment(routeKey, name, value) {
   if (value.trim() === "" || value === "." || value === "..") {
     throw new Error(`Insights route "${routeKey}" has an invalid value for "{${name}}".`);
@@ -514,7 +740,7 @@ function encodePathSegment(routeKey, name, value) {
 }
 function buildRoutePath(routeKey, template, config, pathParams) {
   for (const name of Object.keys(pathParams)) {
-    if (SESSION_PARAM_NAMES.has(name)) {
+    if (SESSION_PATH_PARAM_NAMES.has(name)) {
       throw new Error(`Insights route segment "{${name}}" is session-derived and cannot be overridden.`);
     }
     if (!template.includes(`{${name}}`)) {
@@ -533,7 +759,22 @@ function buildRoutePath(routeKey, template, config, pathParams) {
     return encodePathSegment(routeKey, name, value);
   });
 }
-function buildServiceHeaders(config, service, hasBody) {
+function rtmIdentityHeaders(config, profile) {
+  if (profile === "ids") {
+    return {
+      "X-UiPath-Internal-AccountId": config.organizationId,
+      "X-UiPath-Internal-TenantId": config.tenantId
+    };
+  }
+  if (profile === "tenant-id") {
+    return { "X-UiPath-Internal-TenantId": config.tenantId };
+  }
+  return {
+    "X-UiPath-Internal-AccountName": config.accountName,
+    "X-UiPath-Internal-TenantName": config.tenantName
+  };
+}
+function buildServiceHeaders(config, route, hasBody) {
   const headers = {
     Authorization: `Bearer ${config.authToken}`,
     Accept: "application/json"
@@ -541,9 +782,8 @@ function buildServiceHeaders(config, service, hasBody) {
   if (hasBody) {
     headers["Content-Type"] = "application/json";
   }
-  if (service === "rtm") {
-    headers["X-UiPath-Internal-AccountName"] = config.accountName;
-    headers["X-UiPath-Internal-TenantName"] = config.tenantName;
+  if (route.service === "rtm") {
+    Object.assign(headers, rtmIdentityHeaders(config, route.identityHeaders ?? "names"));
   } else {
     headers["X-UiPath-Internal-AccountId"] = config.organizationId;
     headers["X-UiPath-Internal-TenantId"] = config.tenantId;
@@ -554,19 +794,46 @@ function buildServiceHeaders(config, service, hasBody) {
   }
   return headers;
 }
-function classifyErrorBody(text) {
+var MODEL_PATH_PATTERN = /^[A-Za-z0-9_.[\]]{1,200}$/;
+function describeJsonErrorBody(parsed) {
+  if (typeof parsed === "string") {
+    return { shape: "string" };
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return { shape: "other" };
+  }
+  const record = parsed;
+  const hint = { shape: "object" };
+  if (typeof record.error === "string" && KNOWN_ERROR_LABELS.has(record.error)) {
+    hint.errorLabel = record.error;
+  }
+  if (typeof record.status === "number" && typeof record.title === "string") {
+    hint.problemDetails = true;
+  }
+  const errors = record.errors;
+  if (typeof record.status === "number" && typeof errors === "object" && errors !== null && !Array.isArray(errors)) {
+    const [firstKey] = Object.keys(errors);
+    if (firstKey !== undefined && MODEL_PATH_PATTERN.test(firstKey)) {
+      hint.firstInvalidField = firstKey;
+    }
+  }
+  return hint;
+}
+function describeErrorBody(text) {
   if (!text.trim()) {
-    return "absent";
+    return { kind: "absent" };
   }
   const head = text.trimStart().toLowerCase();
   if (head.startsWith("<!doctype") || head.startsWith("<html")) {
-    return "html";
+    return { kind: "html" };
   }
-  const [parseError] = catchError(() => JSON.parse(text));
+  const [parseError, parsed] = catchError(() => JSON.parse(text));
   if (!parseError) {
-    return "json";
+    return { kind: "json", hint: describeJsonErrorBody(parsed) };
   }
-  return head.startsWith("{") || head.startsWith("[") ? "invalid-json" : "text";
+  return {
+    kind: head.startsWith("{") || head.startsWith("[") ? "invalid-json" : "text"
+  };
 }
 function parseRetryAfterSeconds(header) {
   if (header === null) {
@@ -575,28 +842,57 @@ function parseRetryAfterSeconds(header) {
   const seconds = Number.parseInt(header, 10);
   return Number.isNaN(seconds) || seconds < 0 ? undefined : seconds;
 }
-function httpErrorFrom(response, route, bodyKind, cause) {
+function httpErrorFrom(response, route, body, cause) {
   return new InsightsHttpError({
     status: response.status,
     method: route.method,
     endpoint: route.template,
-    bodyKind,
+    bodyKind: body.kind,
+    bodyHint: body.hint,
     requestId: response.headers.get("x-request-id") ?? undefined,
     retryAfterSeconds: parseRetryAfterSeconds(response.headers.get("retry-after")),
     cause
   });
 }
+function buildRouteQuery(routeKey, route, config, query) {
+  const declared = route.queryParams ?? [];
+  if (declared.length > 0 && route.template.includes("?")) {
+    throw new Error(`Insights route "${routeKey}" declares query parameters and its template already has a "?".`);
+  }
+  for (const name of Object.keys(query)) {
+    if (SESSION_QUERY_PARAM_NAMES.has(name)) {
+      throw new Error(`Insights route query parameter "${name}" is session-derived and cannot be overridden.`);
+    }
+    if (!declared.includes(name)) {
+      throw new Error(`Insights route "${routeKey}" has no "${name}" query parameter.`);
+    }
+  }
+  const values = {
+    ...sessionQueryParams(config),
+    ...query
+  };
+  const search = new URLSearchParams;
+  for (const name of declared) {
+    const value = values[name];
+    if (value !== undefined) {
+      search.append(name, String(value));
+    }
+  }
+  return search.toString();
+}
 async function requestInsightsRoute(config, routeKey, request = {}) {
   const route = INSIGHTS_ROUTES[routeKey];
   if (!route) {
     throw new Error(`Unsupported Insights route "${routeKey}".`);
   }
   const path = buildRoutePath(routeKey, route.template, config, request.pathParams ?? {});
-  const url = `${config.baseUrl}/${encodePathSegment(routeKey, "organizationId", config.organizationId)}/${encodePathSegment(routeKey, "tenantName", config.tenantName)}/${SERVICE_ROOTS[route.service]}/${path}`;
+  const basePath = `${config.baseUrl}/${encodePathSegment(routeKey, "organizationId", config.organizationId)}/${encodePathSegment(routeKey, "tenantName", config.tenantName)}/${SERVICE_ROOTS[route.service]}/${path}`;
+  const search = buildRouteQuery(routeKey, route, config, request.query ?? {});
+  const url = search === "" ? basePath : `${basePath}?${search}`;
   const hasBody = request.body !== undefined;
   const [fetchError, response] = await catchError(fetch(url, {
     method: route.method,
-    headers: buildServiceHeaders(config, route.service, hasBody),
+    headers: buildServiceHeaders(config, route, hasBody),
     body: hasBody ? JSON.stringify(request.body) : undefined
   }));
   if (fetchError) {
@@ -605,12 +901,12 @@ async function requestInsightsRoute(config, routeKey, request = {}) {
   const [readError, text] = await catchError(response.text());
   if (readError) {
     if (!response.ok) {
-      throw httpErrorFrom(response, route, "absent", readError);
+      throw httpErrorFrom(response, route, { kind: "unreadable" }, readError);
     }
     throw new InsightsNetworkError(route.template, readError, "response-body");
   }
   if (!response.ok) {
-    throw httpErrorFrom(response, route, classifyErrorBody(text));
+    throw httpErrorFrom(response, route, describeErrorBody(text));
   }
   if (!text.trim()) {
     if (route.allowsEmptyResponse) {
@@ -722,6 +1018,331 @@ async function createInsightsConfig(tenantOverride) {
     tenantName: ctx.tenantName
   };
 }
+// ../common/src/guid.ts
+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 isGuid(value) {
+  return GUID_REGEX.test(value);
+}
+
+// src/dashboards.ts
+var DASHBOARD_TEMPLATE_ID_PREFIX = "UiPath-";
+var MAESTRO_PROCESS_DASHBOARD_PREFIX = "UiPath-Maestro-process-monitoring";
+var MAESTRO_CASE_DASHBOARD_PREFIX = "UiPath-Maestro-case-monitoring";
+var DASHBOARD_SLOT_DELIMITER = "___";
+var MAESTRO_DASHBOARD_SOURCE_TYPE = "AO";
+var SLOT_PREFIXES = {
+  process: MAESTRO_PROCESS_DASHBOARD_PREFIX,
+  case: MAESTRO_CASE_DASHBOARD_PREFIX
+};
+function composeDashboardSlotId(processKey, kind) {
+  if (!isGuid(processKey)) {
+    throw new Error("Insights dashboard slot ids are composed from a process key GUID.");
+  }
+  return `${SLOT_PREFIXES[kind]}${DASHBOARD_SLOT_DELIMITER}${processKey.toLowerCase()}`;
+}
+function isTemplateKeyedDashboardId(id) {
+  return id.startsWith(DASHBOARD_TEMPLATE_ID_PREFIX);
+}
+function parseDashboardSlotId(id) {
+  for (const [kind, prefix] of Object.entries(SLOT_PREFIXES)) {
+    const head = `${prefix}${DASHBOARD_SLOT_DELIMITER}`;
+    if (id.startsWith(head) && isGuid(id.slice(head.length))) {
+      return { kind, processKey: id.slice(head.length) };
+    }
+  }
+  return;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asRecord(value) {
+  return isRecord(value) ? value : undefined;
+}
+function checkString(value, path) {
+  return typeof value === "string" ? undefined : path;
+}
+function checkBoolean(value, path) {
+  return typeof value === "boolean" ? undefined : path;
+}
+function checkInteger(value, path) {
+  return typeof value === "number" && Number.isInteger(value) ? undefined : path;
+}
+function checkOptional(value, path, check) {
+  return value === undefined || value === null ? undefined : check(value, path);
+}
+function checkNullableString(value, path) {
+  return checkOptional(value, path, checkString);
+}
+function checkArray(value, path, checkItem) {
+  if (!Array.isArray(value)) {
+    return path;
+  }
+  for (const [index, item] of value.entries()) {
+    const fault = checkItem(item, `${path}[${index}]`);
+    if (fault !== undefined) {
+      return fault;
+    }
+  }
+  return;
+}
+function checkNullableArray(value, path, checkItem) {
+  return checkOptional(value, path, (inner, innerPath) => checkArray(inner, innerPath, checkItem));
+}
+function firstFault(...faults) {
+  return faults.find((fault) => fault !== undefined);
+}
+function checkFieldFormat(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkOptional(record.trueDisplay, `${path}.trueDisplay`, checkString), checkOptional(record.falseDisplay, `${path}.falseDisplay`, checkString));
+}
+function checkField(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkString(record.id, `${path}.id`), checkString(record.display, `${path}.display`), checkString(record.type, `${path}.type`), checkOptional(record.hidden, `${path}.hidden`, checkBoolean), checkOptional(record.format, `${path}.format`, checkFieldFormat));
+}
+function checkTable(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkString(record.id, `${path}.id`), checkString(record.display, `${path}.display`), checkArray(record.fields, `${path}.fields`, checkField));
+}
+function checkJsonArray(value, path) {
+  return Array.isArray(value) ? undefined : path;
+}
+function checkMetricFilter(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkNullableString(record.kind, `${path}.kind`), checkNullableString(record.dimension, `${path}.dimension`), checkNullableString(record.type, `${path}.type`), checkBoolean(record.invert, `${path}.invert`), checkOptional(record.values, `${path}.values`, checkJsonArray), checkOptional(record.pattern, `${path}.pattern`, checkString), checkOptional(record.filterType, `${path}.filterType`, checkString));
+}
+function checkMetricExpression(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkNullableString(record.type, `${path}.type`), checkNullableString(record.argument, `${path}.argument`), checkNullableString(record.aggregation, `${path}.aggregation`), checkOptional(record.id, `${path}.id`, checkString), checkNullableArray(record.filters, `${path}.filters`, checkMetricFilter));
+}
+function checkMetric(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkString(record.id, `${path}.id`), checkString(record.display, `${path}.display`), checkOptional(record.expression, `${path}.expression`, checkMetricExpression));
+}
+function checkChartFilterRange(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkOptional(record.inclusive, `${path}.inclusive`, checkBoolean), checkOptional(record.preset, `${path}.preset`, checkString));
+}
+function checkChartFilter(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkNullableString(record.type, `${path}.type`), checkNullableString(record.field, `${path}.field`), checkNullableString(record.valueType, `${path}.valueType`), checkOptional(record.values, `${path}.values`, checkJsonArray), checkOptional(record.range, `${path}.range`, checkChartFilterRange), checkOptional(record.invert, `${path}.invert`, checkBoolean), checkOptional(record.pattern, `${path}.pattern`, checkString), checkOptional(record.searchFilterType, `${path}.searchFilterType`, checkString));
+}
+function checkChartAction(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkNullableString(record.type, `${path}.type`), checkNullableString(record.icon, `${path}.icon`), checkNullableString(record.testId, `${path}.testId`), checkNullableString(record.label, `${path}.label`), checkNullableString(record.tooltip, `${path}.tooltip`), checkNullableString(record.onClickAction, `${path}.onClickAction`));
+}
+function checkChart(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkString(record.type, `${path}.type`), checkNullableArray(record.dimensions, `${path}.dimensions`, checkString), checkNullableArray(record.metrics, `${path}.metrics`, checkString), checkString(record.id, `${path}.id`), checkString(record.name, `${path}.name`), checkNullableArray(record.filters, `${path}.filters`, checkChartFilter), checkNullableArray(record.actions, `${path}.actions`, checkChartAction));
+}
+function checkContainer(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkNullableString(record.id, `${path}.id`), checkOptional(record.chartId, `${path}.chartId`, checkString), checkInteger(record.rowStart, `${path}.rowStart`), checkInteger(record.rowEnd, `${path}.rowEnd`), checkInteger(record.columnStart, `${path}.columnStart`), checkInteger(record.columnEnd, `${path}.columnEnd`));
+}
+function checkCustomLayout(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkInteger(record.columnCount, `${path}.columnCount`), checkInteger(record.rowCount, `${path}.rowCount`), checkNullableArray(record.containers, `${path}.containers`, checkContainer));
+}
+function checkLayout(value, path) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return path;
+  }
+  return firstFault(checkString(record.type, `${path}.type`), checkOptional(record.layout, `${path}.layout`, checkCustomLayout));
+}
+function findDashboardDefinitionFault(value) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return "$";
+  }
+  return firstFault(checkString(record.id, "$.id"), checkString(record.dataModel, "$.dataModel"), checkArray(record.tables, "$.tables", checkTable), checkArray(record.metrics, "$.metrics", checkMetric), checkArray(record.charts, "$.charts", (inner, innerPath) => checkArray(inner, innerPath, checkChart)), checkLayout(record.layout, "$.layout"), checkOptional(record.name, "$.name", checkString), checkOptional(record.isVisible, "$.isVisible", checkBoolean), checkOptional(record.version, "$.version", checkInteger), checkNullableArray(record.filters, "$.filters", checkChartFilter), checkOptional(record.isAllowedToEdit, "$.isAllowedToEdit", checkBoolean));
+}
+function findChartFilterListFault(value) {
+  return checkArray(value, "$", checkChartFilter);
+}
+function requireShape(parsed, routeKey, fault, contractName) {
+  if (fault !== undefined) {
+    throw new InsightsProtocolError(insightsRouteTemplate(routeKey), `body does not match the ${contractName} contract at ${fault}`);
+  }
+  return parsed;
+}
+function requireDefinition(parsed, routeKey) {
+  return requireShape(parsed, routeKey, findDashboardDefinitionFault(parsed), "dashboard definition");
+}
+async function getDashboard(config, options) {
+  const parsed = await requestInsightsRoute(config, "dashboardsGet", {
+    pathParams: {
+      sourceType: options.sourceType,
+      dashboardId: options.dashboardId
+    },
+    query: { localization: options.localization }
+  });
+  return requireDefinition(parsed, "dashboardsGet");
+}
+async function listDashboardFilters(config, options) {
+  const parsed = await requestInsightsRoute(config, "dashboardFiltersList", {
+    pathParams: {
+      sourceType: options.sourceType,
+      dashboardId: options.dashboardId
+    }
+  });
+  return requireShape(parsed, "dashboardFiltersList", findChartFilterListFault(parsed), "dashboard filter list");
+}
+async function getDashboardTemplate(config, options) {
+  const parsed = await requestInsightsRoute(config, "dashboardTemplatesGet", {
+    pathParams: { sourceType: options.sourceType },
+    query: {
+      serviceIdentifier: options.serviceIdentifier,
+      localization: options.localization
+    }
+  });
+  if (typeof parsed !== "string") {
+    throw new InsightsProtocolError(insightsRouteTemplate("dashboardTemplatesGet"), "template body is not a JSON string");
+  }
+  const [parseError, definition] = catchError(() => JSON.parse(parsed));
+  if (parseError) {
+    throw new InsightsProtocolError(insightsRouteTemplate("dashboardTemplatesGet"), "template body is not valid JSON");
+  }
+  return requireDefinition(definition, "dashboardTemplatesGet");
+}
+
+class DashboardRequestError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DashboardRequestError";
+  }
+}
+async function createDashboard(config, options) {
+  const slot = parseDashboardSlotId(options.slotId);
+  if (slot === undefined) {
+    throw new DashboardRequestError("Insights dashboards are created into a process slot id; compose it with composeDashboardSlotId.");
+  }
+  const canonical = composeDashboardSlotId(slot.processKey, slot.kind);
+  if (options.slotId !== canonical) {
+    throw new DashboardRequestError(`Insights dashboard slot id is not canonical; compose it with composeDashboardSlotId (expected ${canonical}).`);
+  }
+  const requestFault = findDashboardDefinitionFault(options.definition);
+  if (requestFault !== undefined) {
+    throw new DashboardRequestError(`Insights dashboard definition is invalid at ${requestFault}.`);
+  }
+  const body = {
+    ...options.definition,
+    id: options.slotId
+  };
+  const parsed = await requestInsightsRoute(config, "dashboardsCreate", {
+    pathParams: { sourceType: MAESTRO_DASHBOARD_SOURCE_TYPE },
+    query: { serviceIdentifier: slot.processKey },
+    body
+  });
+  return requireDefinition(parsed, "dashboardsCreate");
+}
+var NUMERIC_DASHBOARD_ID = /^\d+$/;
+async function updateDashboard(config, options) {
+  if (!NUMERIC_DASHBOARD_ID.test(options.dashboardId)) {
+    throw new DashboardRequestError("Insights dashboards are updated by numeric row id; template-keyed ids are read keys only.");
+  }
+  const requestFault = findDashboardDefinitionFault(options.definition);
+  if (requestFault !== undefined) {
+    throw new DashboardRequestError(`Insights dashboard definition is invalid at ${requestFault}.`);
+  }
+  const parsed = await requestInsightsRoute(config, "dashboardsUpdate", {
+    pathParams: {
+      sourceType: options.sourceType,
+      dashboardId: options.dashboardId
+    },
+    body: options.definition
+  });
+  return requireDefinition(parsed, "dashboardsUpdate");
+}
+function findDeleteAcknowledgementFault(value) {
+  const record = asRecord(value);
+  if (record === undefined) {
+    return "$";
+  }
+  return checkString(record.message, "$.message");
+}
+async function deleteDashboard(config, options) {
+  if (!NUMERIC_DASHBOARD_ID.test(options.dashboardId)) {
+    throw new DashboardRequestError("Insights dashboards are deleted by numeric row id; template-keyed ids are read keys only.");
+  }
+  if (options.dashboardId.startsWith("0")) {
+    throw new DashboardRequestError("Insights dashboard ids carry no leading zero; a padded id would delete the unpadded row and orphan the alert definitions bound to it.");
+  }
+  const parsed = await requestInsightsRoute(config, "dashboardsDelete", {
+    pathParams: {
+      sourceType: options.sourceType,
+      dashboardId: options.dashboardId
+    }
+  });
+  requireShape(parsed, "dashboardsDelete", findDeleteAcknowledgementFault(parsed), "dashboard delete acknowledgement");
+}
+// src/export-configurations.ts
+var MAX_INT32 = 2147483647;
+var CANONICAL_ID_PATTERN = /^[1-9]\d*$/;
+var DESTINATION_KEYS = [
+  "azureEventHub",
+  "awsSqs",
+  "genericEndpoint",
+  "arize",
+  "databricks"
+];
+async function listExportConfigurations(config) {
+  return requestInsightsRoute(config, "exportConfigurationsList");
+}
+async function verifyAllExportDestinations(config) {
+  return requestInsightsRoute(config, "exportDestinationsVerifyAll");
+}
+function countDestinationKeys(destination) {
+  return DESTINATION_KEYS.filter((key) => destination[key] !== undefined && destination[key] !== null).length;
+}
+async function verifyExportDestination(config, configurationId, body) {
+  if (!CANONICAL_ID_PATTERN.test(configurationId) || Number(configurationId) > MAX_INT32) {
+    throw new Error("Insights export configuration id must be a positive integer with no sign and no leading zero.");
+  }
+  const keyCount = countDestinationKeys(body.destination);
+  if (keyCount !== 1) {
+    throw new Error(`Insights export verify body must name exactly one destination type of ${DESTINATION_KEYS.join(", ")}; it names ${keyCount}.`);
+  }
+  return requestInsightsRoute(config, "exportDestinationVerify", {
+    pathParams: { configurationId },
+    body
+  });
+}
 // src/types.ts
 function isStringArrayOrNullish(value) {
   if (value === undefined || value === null) {
@@ -789,6 +1410,224 @@ async function listQueueFilters(config) {
 async function listMachineFilters(config) {
   return listFilters(config, "filtersAllMachines", isMachineFiltersResponse, "machine filters");
 }
+// src/machines.ts
+function isNullish(value) {
+  return value === undefined || value === null;
+}
+function isArrayOfNullable(value, isElement) {
+  if (isNullish(value)) {
+    return true;
+  }
+  return Array.isArray(value) && value.every(isElement);
+}
+function isFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isStringEntry(value) {
+  return typeof value === "string" || value === null;
+}
+function isNumberSeries(value) {
+  return Array.isArray(value) && value.every((entry) => isFiniteNumber(entry));
+}
+var STRING_ARRAY_FIELDS = [
+  "machineName",
+  "hostMachineName",
+  "machineKey",
+  "machineStatus",
+  "startTime",
+  "endTime",
+  "eventTime",
+  "processName",
+  "machineType"
+];
+var NUMBER_ARRAY_FIELDS = [
+  "jobCount",
+  "jobDuration",
+  "machineUtilization",
+  "runtimeCount",
+  "inUseCount"
+];
+var ALL_MACHINE_FIELDS = [
+  ...STRING_ARRAY_FIELDS,
+  ...NUMBER_ARRAY_FIELDS,
+  "runtimeSlots"
+];
+function hasWellTypedFields(record) {
+  return STRING_ARRAY_FIELDS.every((field) => isArrayOfNullable(record[field], isStringEntry)) && NUMBER_ARRAY_FIELDS.every((field) => isArrayOfNullable(record[field], isFiniteNumber)) && isArrayOfNullable(record.runtimeSlots, isNumberSeries);
+}
+function isMachinesResponse(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!hasWellTypedFields(record)) {
+    return false;
+  }
+  return Object.keys(record).length === 0 || ALL_MACHINE_FIELDS.some((field) => (field in record));
+}
+async function queryMachines(config, queryId, input) {
+  const parsed = await requestInsightsRoute(config, "machinesQuery", {
+    body: {
+      ...input,
+      queryId,
+      orgId: config.organizationId,
+      tenantId: config.tenantId
+    }
+  });
+  if (!isMachinesResponse(parsed)) {
+    throw new InsightsProtocolError(insightsRouteTemplate("machinesQuery"), `body does not match the machine query ${queryId} contract`);
+  }
+  return parsed;
+}
+async function getMachineRuntimeMix(config, input) {
+  return queryMachines(config, 1, input);
+}
+async function getMachineDetails(config, input) {
+  return queryMachines(config, 2, input);
+}
+async function getMachineAvailabilityTimeline(config, input) {
+  return queryMachines(config, 3, input);
+}
+async function getMachineTopFailures(config, input) {
+  return queryMachines(config, 4, input);
+}
+async function getMachineUtilization(config, input) {
+  return queryMachines(config, 5, input);
+}
+// src/queues.ts
+function isNullish2(value) {
+  return value === undefined || value === null;
+}
+function isArrayOfNullable2(value, isElement) {
+  if (isNullish2(value)) {
+    return true;
+  }
+  return Array.isArray(value) && value.every(isElement);
+}
+function isFiniteNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function isStringEntry2(value) {
+  return typeof value === "string" || value === null;
+}
+function isNumberSeries2(value) {
+  return Array.isArray(value) && value.every((entry) => isFiniteNumber2(entry));
+}
+function isWfMetricsRow(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var STRING_ARRAY_FIELDS2 = [
+  "queueState",
+  "robotName",
+  "machineName",
+  "processName",
+  "folderName",
+  "folderKey",
+  "queueName",
+  "dueDate",
+  "reference",
+  "priority",
+  "startTime",
+  "endTime",
+  "hostMachineName",
+  "processingExceptionReason",
+  "processingExceptionType",
+  "creationTime",
+  "folderId",
+  "queueItemKey",
+  "firstBreachSLA",
+  "firstBreachRisk"
+];
+var NUMBER_ARRAY_FIELDS2 = [
+  "duration",
+  "queueCount",
+  "queueItemId",
+  "successRate",
+  "inSLACount",
+  "riskSLACount",
+  "outSLACount",
+  "avgHandlingTime",
+  "avgPendingTime",
+  "runningRobotCnt",
+  "necessaryRobotCnt",
+  "queueId"
+];
+var NUMBER_SERIES_FIELDS = [
+  "queueCountByTime",
+  "queueCounts",
+  "queueAggregate"
+];
+var SCALAR_NUMBER_FIELDS = [
+  "averageProcessingTime",
+  "queueItemCount",
+  "successfulQueueItemsCount"
+];
+var ALL_QUEUE_FIELDS = [
+  ...STRING_ARRAY_FIELDS2,
+  ...NUMBER_ARRAY_FIELDS2,
+  ...NUMBER_SERIES_FIELDS,
+  ...SCALAR_NUMBER_FIELDS,
+  "wfMetrics"
+];
+function hasWellTypedFields2(record) {
+  return STRING_ARRAY_FIELDS2.every((field) => isArrayOfNullable2(record[field], isStringEntry2)) && NUMBER_ARRAY_FIELDS2.every((field) => isArrayOfNullable2(record[field], isFiniteNumber2)) && NUMBER_SERIES_FIELDS.every((field) => isArrayOfNullable2(record[field], isNumberSeries2)) && SCALAR_NUMBER_FIELDS.every((field) => isNullish2(record[field]) || isFiniteNumber2(record[field])) && isArrayOfNullable2(record.wfMetrics, isWfMetricsRow);
+}
+function isQueuesResponse(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  if (!hasWellTypedFields2(record)) {
+    return false;
+  }
+  return Object.keys(record).length === 0 || ALL_QUEUE_FIELDS.some((field) => (field in record));
+}
+var EMPTY_DEDICATED_SAAS_FILTERS = { airId: [], tenantFilter: [] };
+async function queryQueues(config, queryId, input) {
+  const parsed = await requestInsightsRoute(config, "queuesQuery", {
+    body: {
+      ...input,
+      queryId,
+      orgId: config.organizationId,
+      tenantId: config.tenantId,
+      ...EMPTY_DEDICATED_SAAS_FILTERS
+    }
+  });
+  if (!isQueuesResponse(parsed)) {
+    throw new InsightsProtocolError(insightsRouteTemplate("queuesQuery"), `body does not match the queue query ${queryId} contract`);
+  }
+  return parsed;
+}
+async function getQueueCompletedTimeline(config, input) {
+  return queryQueues(config, 3, input);
+}
+async function getQueueUncompletedTimeline(config, input) {
+  return queryQueues(config, 10, input);
+}
+async function getQueueTopFailures(config, input) {
+  return queryQueues(config, 11, input);
+}
+async function getQueueFailuresByReason(config, input) {
+  return queryQueues(config, 12, input);
+}
+async function getQueueDetails(config, input) {
+  return queryQueues(config, 13, input);
+}
+async function getQueueRetryOutcomes(config, input) {
+  return queryQueues(config, 14, input);
+}
+async function getQueueSummary(config, input) {
+  return queryQueues(config, 15, input);
+}
+async function getQueueFailureDetails(config, input) {
+  return queryQueues(config, 16, input);
+}
+async function getQueueSla(config, input) {
+  return queryQueues(config, 17, input);
+}
+async function getQueueOperationalMetrics(config, input) {
+  return queryQueues(config, 18, input);
+}
 // src/rbac.ts
 async function listUsers(config) {
   return requestInsightsRoute(config, "usersList");
@@ -820,30 +1659,68 @@ async function checkInsightsAccess(config, request) {
   });
 }
 export {
+  CREATE_BACKEND_FAILURE_LABEL,
+  DASHBOARD_NOT_FOUND_LABEL,
+  DASHBOARD_SLOT_DELIMITER,
+  DASHBOARD_TEMPLATE_ID_PREFIX,
+  DashboardRequestError,
   InsightsHttpError,
   InsightsNetworkError,
   InsightsProtocolError,
+  MAESTRO_CASE_DASHBOARD_PREFIX,
+  MAESTRO_DASHBOARD_SOURCE_TYPE,
+  MAESTRO_PROCESS_DASHBOARD_PREFIX,
+  MODEL_NOT_FOUND_LABEL,
+  UPDATE_BACKEND_FAILURE_LABEL,
+  VALIDATION_FAILED_LABEL,
   checkAlertEntitlement,
   checkInsightsAccess,
+  composeDashboardSlotId,
+  createDashboard,
   createInsightsConfig,
   deleteAlertDefinition,
+  deleteDashboard,
   getAlertDefinition,
   getAlertHistoryMetrics,
+  getDashboard,
+  getDashboardTemplate,
   getDefaultDelivery,
   getGroup,
+  getMachineAvailabilityTimeline,
+  getMachineDetails,
+  getMachineRuntimeMix,
+  getMachineTopFailures,
+  getMachineUtilization,
+  getQueueCompletedTimeline,
+  getQueueDetails,
+  getQueueFailureDetails,
+  getQueueFailuresByReason,
+  getQueueOperationalMetrics,
+  getQueueRetryOutcomes,
+  getQueueSla,
+  getQueueSummary,
+  getQueueTopFailures,
+  getQueueUncompletedTimeline,
   getRole,
   getUser,
   insightsPost,
+  isTemplateKeyedDashboardId,
   listAgenticAlertDefinitions,
   listAlertDefinitions,
   listAlertHistoryDetails,
+  listDashboardFilters,
+  listExportConfigurations,
   listFolderFilters,
   listGroups,
   listMachineFilters,
   listProcessFilters,
   listQueueFilters,
   listRoles,
-  listUsers
+  listUsers,
+  parseDashboardSlotId,
+  updateDashboard,
+  verifyAllExportDestinations,
+  verifyExportDestination
 };
 
-//# debugId=8080AC24058A453F64756E2164756E21
+//# debugId=3D6C08297457188064756E2164756E21