@uipath/uipath-typescript 1.4.2 → 1.5.1

package/dist/index.d.ts

@@ -3312,6 +3312,446 @@ declare class ChoiceSetService extends BaseService implements ChoiceSetServiceMo
     private resolveChoiceSetName;
 }
 
+/**
+ * @internal
+ */
+declare enum DataFabricRoleType {
+    System = "System",
+    UserDefined = "UserDefined"
+}
+/**
+ * @internal
+ */
+interface DataFabricRole {
+    id: string;
+    name: string;
+    type: DataFabricRoleType;
+    directoryEntityCount?: number | null;
+    folderId?: string;
+}
+/**
+ * @internal
+ */
+interface DataFabricRoleGetAllOptions {
+    /**
+     * Include role statistics in the response.
+     *
+     * Defaults to true to match the Data Fabric UI and CLI role-list flow.
+     */
+    stats?: boolean;
+    /**
+     * Optional folder key for folder-aware Role V2 requests.
+     *
+     * Forwarded on the wire as the `X-UIPATH-FolderKey` header.
+     */
+    folderKey?: string;
+}
+
+/**
+ * @internal
+ */
+interface DataFabricRoleServiceModel {
+    /**
+     * Lists Data Fabric access roles.
+     *
+     * Returns tenant Data Fabric roles such as Admin, Designer, DataWriter, and
+     * DataReader. Role IDs from this method can be passed to
+     * `DataFabricDirectoryService.assignRoles()`.
+     *
+     * @param options - Optional query options
+     * @returns Promise resolving to an array of {@link DataFabricRole}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const allRoles = await roles.getAll();
+     * const dataWriter = allRoles.find(role => role.name === 'DataWriter');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const rolesWithoutStats = await roles.getAll({ stats: false });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const folderRoles = await roles.getAll({ folderKey: '<folder-key>' });
+     * ```
+     *
+     * @internal
+     */
+    getAll(options?: DataFabricRoleGetAllOptions): Promise<DataFabricRole[]>;
+}
+
+/**
+ * @internal
+ */
+declare class DataFabricRoleService extends BaseService implements DataFabricRoleServiceModel {
+    /**
+     * Lists Data Fabric access roles.
+     *
+     * Returns tenant Data Fabric roles such as Admin, Designer, DataWriter, and
+     * DataReader. Role IDs from this method can be passed to
+     * `DataFabricDirectoryService.assignRoles()`.
+     *
+     * @param options - Optional query options
+     * @returns Promise resolving to an array of {@link DataFabricRole}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const allRoles = await roles.getAll();
+     * const dataWriter = allRoles.find(role => role.name === 'DataWriter');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const rolesWithoutStats = await roles.getAll({ stats: false });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * const folderRoles = await roles.getAll({ folderKey: '<folder-key>' });
+     * ```
+     *
+     * @internal
+     */
+    getAll(options?: DataFabricRoleGetAllOptions): Promise<DataFabricRole[]>;
+}
+
+/**
+ * @internal
+ */
+declare enum DataFabricDirectoryEntityType {
+    /** Identity user, robot user, or directory robot principal. */
+    User = 0,
+    /** Identity group principal. */
+    Group = 1,
+    /** External application principal. */
+    Application = 2
+}
+/**
+ * @internal
+ */
+declare enum DataFabricDirectoryEntityTypeName {
+    User = "User",
+    Group = "Group",
+    Application = "Application"
+}
+/**
+ * @internal
+ */
+type DataFabricDirectoryEntityTypeInput = DataFabricDirectoryEntityType | DataFabricDirectoryEntityTypeName;
+/**
+ * @internal
+ */
+interface DataFabricDirectoryRole {
+    id: string;
+    name: string;
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryEntry {
+    externalId: string;
+    name: string;
+    email?: string | null;
+    type: DataFabricDirectoryEntityTypeName;
+    roles: DataFabricDirectoryRole[];
+    objectType?: string | null;
+    isUIEnabled: boolean;
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryListOptions {
+    skip?: number;
+    top?: number;
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryGetAllOptions {
+    pageSize?: number;
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryListResponse {
+    totalCount: number;
+    results: DataFabricDirectoryEntry[];
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryAssignOptions {
+    /**
+     * Preserve the principal's current Data Fabric roles.
+     *
+     * Defaults to true because the Data Fabric role assignment endpoint replaces
+     * the role set for each principal.
+     */
+    preserveExisting?: boolean;
+    /**
+     * Enables Data Fabric UI access for the assigned principal.
+     *
+     * Defaults to true.
+     */
+    uiEnabled?: boolean;
+}
+/**
+ * @internal
+ */
+interface DataFabricDirectoryAssignmentResult {
+    principalId: string;
+    roleIds: string[];
+}
+
+/**
+ * @internal
+ */
+interface DataFabricDirectoryServiceModel {
+    /**
+     * Lists one page of Data Fabric directory principals and their current roles.
+     *
+     * Returns directory entries with external IDs, principal metadata, and
+     * assigned Data Fabric roles.
+     *
+     * @param options - Optional offset paging options
+     * @returns Promise resolving to {@link DataFabricDirectoryListResponse}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const page = await directory.list({ skip: 0, top: 50 });
+     * const firstPrincipal = page.results[0];
+     * ```
+     *
+     * @internal
+     */
+    list(options?: DataFabricDirectoryListOptions): Promise<DataFabricDirectoryListResponse>;
+    /**
+     * Lists all Data Fabric directory principals and their current roles.
+     *
+     * Follows the Data Fabric directory top/skip pagination and returns
+     * normalized entries. Entries without assigned roles include an empty
+     * `roles` array.
+     *
+     * @param options - Optional page-size options
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryEntry}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const principals = await directory.getAll({ pageSize: 100 });
+     * ```
+     *
+     * @internal
+     */
+    getAll(options?: DataFabricDirectoryGetAllOptions): Promise<DataFabricDirectoryEntry[]>;
+    /**
+     * Assigns Data Fabric roles to one or more principals.
+     *
+     * The Data Fabric API replaces the role set for each principal, so this
+     * method preserves existing roles by default and posts the union of current
+     * and requested role IDs.
+     *
+     * Role IDs can be discovered with `DataFabricRoleService.getAll()`. Set
+     * `preserveExisting: false` only when intentionally replacing a principal's
+     * Data Fabric role set.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @param principalType - Principal type
+     * @param roleIds - Data Fabric role IDs to assign
+     * @param options - Optional assignment behavior
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryAssignmentResult}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryEntityTypeName, DataFabricDirectoryService, DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * const dataWriter = (await roles.getAll()).find(role => role.name === 'DataWriter');
+     * if (!dataWriter) {
+     *   throw new Error('DataWriter role not found');
+     * }
+     *
+     * await directory.assignRoles('<identity-group-id>', DataFabricDirectoryEntityTypeName.Group, [dataWriter.id]);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.assignRoles('<identity-user-id>', DataFabricDirectoryEntityTypeName.User, ['<role-id>'], {
+     *   preserveExisting: false,
+     * });
+     * ```
+     *
+     * @internal
+     */
+    assignRoles(principalIds: string | string[], principalType: DataFabricDirectoryEntityTypeInput, roleIds: string[], options?: DataFabricDirectoryAssignOptions): Promise<DataFabricDirectoryAssignmentResult[]>;
+    /**
+     * Revokes all direct Data Fabric roles from one or more principals.
+     *
+     * The Data Fabric API removes all role assignments for each supplied external
+     * ID. Use this when a principal should no longer have direct Data Fabric
+     * access. Inherited access through groups is not changed.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @returns Promise resolving when the roles are revoked
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * await directory.revokeRoles('<identity-user-id>');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.revokeRoles([
+     *   '<identity-user-id>',
+     *   '<identity-group-id>',
+     * ]);
+     * ```
+     *
+     * @internal
+     */
+    revokeRoles(principalIds: string | string[]): Promise<void>;
+}
+
+/**
+ * @internal
+ */
+declare class DataFabricDirectoryService extends BaseService implements DataFabricDirectoryServiceModel {
+    private fetchAllEntries;
+    /**
+     * Lists one page of Data Fabric directory principals and their current roles.
+     *
+     * Returns directory entries with external IDs, principal metadata, and
+     * assigned Data Fabric roles.
+     *
+     * @param options - Optional offset paging options
+     * @returns Promise resolving to {@link DataFabricDirectoryListResponse}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const page = await directory.list({ skip: 0, top: 50 });
+     * const firstPrincipal = page.results[0];
+     * ```
+     *
+     * @internal
+     */
+    list(options?: DataFabricDirectoryListOptions): Promise<DataFabricDirectoryListResponse>;
+    /**
+     * Lists all Data Fabric directory principals and their current roles.
+     *
+     * Follows the Data Fabric directory top/skip pagination and returns
+     * normalized entries. Entries without assigned roles include an empty
+     * `roles` array.
+     *
+     * @param options - Optional page-size options
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryEntry}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     * const principals = await directory.getAll({ pageSize: 100 });
+     * ```
+     *
+     * @internal
+     */
+    getAll(options?: DataFabricDirectoryGetAllOptions): Promise<DataFabricDirectoryEntry[]>;
+    /**
+     * Assigns Data Fabric roles to one or more principals.
+     *
+     * The Data Fabric API replaces the role set for each principal, so this
+     * method preserves existing roles by default and posts the union of current
+     * and requested role IDs.
+     *
+     * Role IDs can be discovered with `DataFabricRoleService.getAll()`. Set
+     * `preserveExisting: false` only when intentionally replacing a principal's
+     * Data Fabric role set.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @param principalType - Principal type
+     * @param roleIds - Data Fabric role IDs to assign
+     * @param options - Optional assignment behavior
+     * @returns Promise resolving to an array of {@link DataFabricDirectoryAssignmentResult}
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryEntityTypeName, DataFabricDirectoryService, DataFabricRoleService } from '@uipath/uipath-typescript/entities';
+     *
+     * const roles = new DataFabricRoleService(sdk);
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * const dataWriter = (await roles.getAll()).find(role => role.name === 'DataWriter');
+     * if (!dataWriter) {
+     *   throw new Error('DataWriter role not found');
+     * }
+     *
+     * await directory.assignRoles('<identity-group-id>', DataFabricDirectoryEntityTypeName.Group, [dataWriter.id]);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.assignRoles('<identity-user-id>', DataFabricDirectoryEntityTypeName.User, ['<role-id>'], {
+     *   preserveExisting: false,
+     * });
+     * ```
+     *
+     * @internal
+     */
+    assignRoles(principalIds: string | string[], principalType: DataFabricDirectoryEntityTypeInput, roleIds: string[], options?: DataFabricDirectoryAssignOptions): Promise<DataFabricDirectoryAssignmentResult[]>;
+    /**
+     * Revokes all direct Data Fabric roles from one or more principals.
+     *
+     * The Data Fabric API removes all role assignments for each supplied external
+     * ID. Use this when a principal should no longer have direct Data Fabric
+     * access. Inherited access through groups is not changed.
+     *
+     * @param principalIds - Principal external ID or IDs
+     * @returns Promise resolving when the roles are revoked
+     *
+     * @example
+     * ```typescript
+     * import { DataFabricDirectoryService } from '@uipath/uipath-typescript/entities';
+     *
+     * const directory = new DataFabricDirectoryService(sdk);
+     *
+     * await directory.revokeRoles('<identity-user-id>');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * await directory.revokeRoles([
+     *   '<identity-user-id>',
+     *   '<identity-group-id>',
+     * ]);
+     * ```
+     *
+     * @internal
+     */
+    revokeRoles(principalIds: string | string[]): Promise<void>;
+}
+
 /**
  * Insights Types
  * Shared types for Maestro insights analytics endpoints
@@ -3387,6 +3827,12 @@ interface TimelineOptions {
      * @default TimeInterval.Day
      */
     groupBy?: TimeInterval;
+    /** Filter by package identifier */
+    packageId?: string;
+    /** Filter by package version */
+    version?: string;
+    /** Filter by one or more process keys. Pass `['<processKey>']` for a single process. */
+    processKeys?: string[];
 }
 /**
  * Final instance statuses returned by the instance status timeline endpoint.
@@ -3415,16 +3861,89 @@ interface InstanceStatusTimelineResponse {
     count: number;
 }
 /**
- * Response for the top duration Insights endpoint
+ * Incident count within a specific time bucket.
+ */
+interface IncidentTimelineResponse {
+    /** Start of the time bucket in local timezone (ISO 8601, e.g. `"2026-05-04T00:00:00"`) */
+    startTime: string;
+    /** End of the time bucket in local timezone (ISO 8601, e.g. `"2026-05-11T00:00:00"`) */
+    endTime: string;
+    /** Number of incidents that occurred within this time bucket */
+    count: number;
+}
+/**
+ * Response for the top duration Insights endpoint
+ */
+interface GetTopDurationResponse extends GetTopBaseResponse {
+    /** Total execution duration in milliseconds */
+    duration: number;
+}
+/**
+ * Duration percentile stats shared by Insights aggregate endpoints (per-element and per-process/case).
+ *
+ * For instance-level stats, durations are computed over terminal instances only
+ * (Completed, Cancelled, Deleted) and default to `0` when no terminal instances exist.
+ */
+interface DurationStats {
+    /** Minimum duration in milliseconds */
+    minDurationMs: number;
+    /** Maximum duration in milliseconds */
+    maxDurationMs: number;
+    /** Average duration in milliseconds */
+    avgDurationMs: number;
+    /** 50th percentile (median) duration in milliseconds */
+    p50DurationMs: number;
+    /** 95th percentile duration in milliseconds */
+    p95DurationMs: number;
+    /** 99th percentile duration in milliseconds */
+    p99DurationMs: number;
+}
+/**
+ * Instance count and duration stats aggregated by status for a process or case within a time range.
+ *
+ * Duration fields are computed over terminal instances only (Completed, Cancelled, Deleted)
+ * and default to `0` when no terminal instances exist in the time range.
+ */
+interface InstanceStats extends DurationStats {
+    /** Total number of instances across all statuses */
+    totalCount: number;
+    /** Number of currently running instances */
+    runningCount: number;
+    /** Number of instances in transitioning state */
+    transitioningCount: number;
+    /** Number of paused instances */
+    pausedCount: number;
+    /** Number of faulted instances */
+    faultedCount: number;
+    /** Number of completed instances */
+    completedCount: number;
+    /** Number of cancelled instances */
+    cancelledCount: number;
+    /** Number of deleted instances */
+    deletedCount: number;
+}
+/**
+ * Required request parameters for process-scoped insights stats endpoints
+ * (`getElementStats`, `getInstanceStats`).
+ *
+ * Identifies a single process+package+version and the time range to aggregate over.
  */
-interface GetTopDurationResponse extends GetTopBaseResponse {
-    /** Total execution duration in milliseconds */
-    duration: number;
+interface MaestroProcessStatsRequest {
+    /** Process key to filter by */
+    processKey: string;
+    /** Package identifier */
+    packageId: string;
+    /** Package version to filter by */
+    packageVersion: string;
+    /** Start of the time range to query */
+    startTime: Date;
+    /** End of the time range to query */
+    endTime: Date;
 }
 /**
- * Element count by status for a BPMN element within a process or case
+ * Per-element execution counts and duration percentiles for a BPMN element within a process or case.
  */
-interface ElementStats {
+interface ElementStats extends DurationStats {
     /** BPMN element identifier */
     elementId: string;
     /** Number of successful executions */
@@ -3437,18 +3956,6 @@ interface ElementStats {
     pausedCount: number;
     /** Number of in-progress executions */
     inProgressCount: number;
-    /** Minimum duration in milliseconds */
-    minDurationMs: number;
-    /** Maximum duration in milliseconds */
-    maxDurationMs: number;
-    /** Average duration in milliseconds */
-    avgDurationMs: number;
-    /** 50th percentile (median) duration in milliseconds */
-    p50DurationMs: number;
-    /** 95th percentile duration in milliseconds */
-    p95DurationMs: number;
-    /** 99th percentile duration in milliseconds */
-    p99DurationMs: number;
 }
 
 /**
@@ -3766,7 +4273,7 @@ interface MaestroProcessesServiceModel {
      *
      * @param startTime - Start of the time range to query
      * @param endTime - End of the time range to query
-     * @param options - Optional settings for time bucketing granularity
+     * @param options - Optional settings for filtering and time bucket granularity
      * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
      *
      * @example
@@ -3793,11 +4300,62 @@ interface MaestroProcessesServiceModel {
      *
      * @example
      * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getInstanceStatusTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Get all-time data (from Unix epoch to now)
      * const allTime = await maestroProcesses.getInstanceStatusTimeline(new Date(0), new Date());
      * ```
      */
     getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for maestro processes.
+     *
+     * Returns time-grouped counts of incidents that occurred within each bucket,
+     * useful for rendering incident time-series charts. Use `groupBy` to control
+     * the time bucket size (hour, day, or week) — defaults to day if not provided.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily incident counts for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const incidents = await maestroProcesses.getIncidentsTimeline(sevenDaysAgo, now);
+     *
+     * for (const incident of incidents) {
+     *   console.log(`${incident.startTime} → ${incident.endTime}: ${incident.count} incidents`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * // Get weekly breakdown
+     * const incidents = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<IncidentTimelineResponse[]>;
     /**
      * Get the top 5 processes ranked by total duration within a time range.
      *
@@ -3842,22 +4400,22 @@ interface MaestroProcessesServiceModel {
      * Returns per-element execution counts (success, fail, terminated, paused, in-progress) and
      * duration percentile metrics (min, max, avg, p50, p95, p99) for BPMN elements within a process.
      *
-     * @param processKey - Process key to filter by
-     * @param packageId - Package identifier
-     * @param startTime - Start of the time range to query
-     * @param endTime - End of the time range to query
-     * @param packageVersion - Package version to filter by
+     * @param request - Process scope + time range to aggregate over
      * @returns Promise resolving to an array of {@link ElementStats}
      * @example
      * ```typescript
-     * // Get element metrics for a process
-     * const elements = await maestroProcesses.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
-     *   new Date('2026-04-01'),
-     *   new Date(),
-     *   '1.0.1'
-     * );
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get element metrics for that process
+     * const elements = await maestroProcesses.getElementStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
      *
      * // Analyze element performance
      * for (const element of elements) {
@@ -3865,9 +4423,52 @@ interface MaestroProcessesServiceModel {
      *   console.log(`  Success: ${element.successCount}, Failed: ${element.failCount}`);
      *   console.log(`  Avg duration: ${element.avgDurationMs}ms, P95: ${element.p95DurationMs}ms`);
      * }
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundElements = await process.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   process.packageVersions[0]
+     * );
+     * ```
+     */
+    getElementStats(request: MaestroProcessStatsRequest): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for a process.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a process within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get instance status breakdown for that process
+     * const counts = await maestroProcesses.getInstanceStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Running: ${counts.runningCount}, Completed: ${counts.completedCount}`);
+     * console.log(`Faulted: ${counts.faultedCount}, Avg duration: ${counts.avgDurationMs}ms`);
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundCounts = await process.getInstanceStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   process.packageVersions[0]
+     * );
      * ```
      */
-    getElementStats(processKey: string, packageId: string, startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    getInstanceStats(request: MaestroProcessStatsRequest): Promise<InstanceStats>;
 }
 interface ProcessMethods {
     /**
@@ -3885,6 +4486,33 @@ interface ProcessMethods {
      * @returns Promise resolving to an array of {@link ElementStats}
      */
     getElementStats(startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for this process
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param packageVersion - Package version to filter by
+     * @returns Promise resolving to {@link InstanceStats}
+     */
+    getInstanceStats(startTime: Date, endTime: Date, packageVersion: string): Promise<InstanceStats>;
+    /**
+     * Get instance status counts aggregated by date for this process.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity (processKey is auto-captured from this process)
+     * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+     */
+    getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: Omit<TimelineOptions, 'processKeys'>): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for this process.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity (processKey is auto-captured from this process)
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: Omit<TimelineOptions, 'processKeys'>): Promise<IncidentTimelineResponse[]>;
 }
 type MaestroProcessGetAllResponse = RawMaestroProcessGetAllResponse & ProcessMethods;
 /**
@@ -4062,7 +4690,10 @@ declare enum JobState {
     Successful = "Successful",
     Stopped = "Stopped",
     Suspended = "Suspended",
-    Resumed = "Resumed"
+    Resumed = "Resumed",
+    Cancelled = "Cancelled",
+    /** Server-side fallback for an unrecognized or missing job state. */
+    Unknown = "Unknown"
 }
 interface BaseOptions {
     expand?: string;
@@ -4145,7 +4776,7 @@ interface ProcessInstancesServiceModel {
      */
     getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
     /**
-     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * Get a process instance by ID with operation methods (cancel, pause, resume, retry)
      * @param id The ID of the instance to retrieve
      * @param folderKey The folder key for authorization
      * @returns Promise resolving to a process instance
@@ -4264,6 +4895,35 @@ interface ProcessInstancesServiceModel {
      * @returns Promise resolving to operation result with instance data
      */
     resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Retry a faulted process instance
+     *
+     * Re-runs the failed elements of the instance (and the elements that follow) within the
+     * same instance, spawning new jobs. Use to recover from transient/flaky failures.
+     * @param instanceId The ID of the instance to retry
+     * @param folderKey The folder key for authorization
+     * @param options Optional retry options with comment
+     * @returns Promise resolving to operation result with instance data
+     * @example
+     * ```typescript
+     * // Retry a faulted process instance
+     * const result = await processInstances.retry(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     *
+     * // Or using instance method
+     * const instance = await processInstances.getById(
+     *   <instanceId>,
+     *   <folderKey>
+     * );
+     * if (instance.latestRunStatus === 'Faulted') {
+     *   const result = await instance.retry({ comment: 'Retrying flaky failure' });
+     *   console.log(`Retried: ${result.success}`);
+     * }
+     * ```
+     */
+    retry(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
     /**
      * Get global variables for a process instance
      *
@@ -4344,6 +5004,13 @@ interface ProcessInstanceMethods {
      * @returns Promise resolving to operation result
      */
     resume(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Retries this faulted process instance
+     *
+     * @param options - Optional retry options with comment
+     * @returns Promise resolving to operation result
+     */
+    retry(options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
     /**
      * Gets incidents for this process instance
      *
@@ -4639,7 +5306,7 @@ interface CasesServiceModel {
      *
      * @param startTime - Start of the time range to query
      * @param endTime - End of the time range to query
-     * @param options - Optional settings for time bucketing granularity
+     * @param options - Optional settings for filtering and time bucket granularity
      * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
      *
      * @example
@@ -4666,11 +5333,62 @@ interface CasesServiceModel {
      *
      * @example
      * ```typescript
+     * // Filter to a specific case process
+     * const filtered = await cases.getInstanceStatusTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Get all-time data (from Unix epoch to now)
      * const allTime = await cases.getInstanceStatusTimeline(new Date(0), new Date());
      * ```
      */
     getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for case management processes.
+     *
+     * Returns time-grouped counts of incidents that occurred within each bucket,
+     * useful for rendering incident time-series charts. Use `groupBy` to control
+     * the time bucket size (hour, day, or week) — defaults to day if not provided.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily incident counts for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const incidents = await cases.getIncidentsTimeline(sevenDaysAgo, now);
+     *
+     * for (const incident of incidents) {
+     *   console.log(`${incident.startTime} → ${incident.endTime}: ${incident.count} incidents`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/cases';
+     *
+     * // Get weekly breakdown
+     * const incidents = await cases.getIncidentsTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter to a specific case process
+     * const filtered = await cases.getIncidentsTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<IncidentTimelineResponse[]>;
     /**
      * Get the top 5 case processes ranked by total duration within a time range.
      *
@@ -4715,31 +5433,73 @@ interface CasesServiceModel {
      * Returns per-element execution counts (success, fail, terminated, paused, in-progress) and
      * duration percentile metrics (min, max, avg, p50, p95, p99) for BPMN elements within a case.
      *
-     * @param processKey - Process key to filter by
-     * @param packageId - Package identifier
-     * @param startTime - Start of the time range to query
-     * @param endTime - End of the time range to query
-     * @param packageVersion - Package version to filter by
+     * @param request - Process scope + time range to aggregate over
      * @returns Promise resolving to an array of {@link ElementStats}
      * @example
      * ```typescript
-     * // Get element metrics for a case
-     * const elements = await cases.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
-     *   new Date('2026-04-01'),
-     *   new Date(),
-     *   '1.0.1'
-     * );
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get element metrics for that case
+     * const elements = await cases.getElementStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
      *
      * // Find elements with failures
      * const failedElements = elements.filter(e => e.failCount > 0);
      * for (const element of failedElements) {
      *   console.log(`Failed element: ${element.elementId}, failures: ${element.failCount}`);
      * }
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundElements = await caseItem.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.packageVersions[0]
+     * );
+     * ```
+     */
+    getElementStats(request: MaestroProcessStatsRequest): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for a case.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a case within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get instance status breakdown for that case
+     * const counts = await cases.getInstanceStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Completed: ${counts.completedCount}, Faulted: ${counts.faultedCount}`);
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundCounts = await caseItem.getInstanceStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.packageVersions[0]
+     * );
      * ```
      */
-    getElementStats(processKey: string, packageId: string, startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    getInstanceStats(request: MaestroProcessStatsRequest): Promise<InstanceStats>;
 }
 interface CaseMethods {
     /**
@@ -4751,6 +5511,33 @@ interface CaseMethods {
      * @returns Promise resolving to an array of {@link ElementStats}
      */
     getElementStats(startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for this case
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param packageVersion - Package version to filter by
+     * @returns Promise resolving to {@link InstanceStats}
+     */
+    getInstanceStats(startTime: Date, endTime: Date, packageVersion: string): Promise<InstanceStats>;
+    /**
+     * Get instance status counts aggregated by date for this case process.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity (processKey is auto-captured from this case)
+     * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+     */
+    getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: Omit<TimelineOptions, 'processKeys'>): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for this case process.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity (processKey is auto-captured from this case)
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: Omit<TimelineOptions, 'processKeys'>): Promise<IncidentTimelineResponse[]>;
 }
 type CaseGetAllWithMethodsResponse = CaseGetAllResponse & CaseMethods;
 /**
@@ -6240,7 +7027,7 @@ declare class MaestroProcessesService extends BaseService implements MaestroProc
      *
      * @param startTime - Start of the time range to query
      * @param endTime - End of the time range to query
-     * @param options - Optional settings for time bucketing granularity
+     * @param options - Optional settings for filtering and time bucket granularity
      * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
      *
      * @example
@@ -6267,11 +7054,62 @@ declare class MaestroProcessesService extends BaseService implements MaestroProc
      *
      * @example
      * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getInstanceStatusTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Get all-time data (from Unix epoch to now)
      * const allTime = await maestroProcesses.getInstanceStatusTimeline(new Date(0), new Date());
      * ```
      */
     getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for maestro processes.
+     *
+     * Returns time-grouped counts of incidents that occurred within each bucket,
+     * useful for rendering incident time-series charts. Use `groupBy` to control
+     * the time bucket size (hour, day, or week) — defaults to day if not provided.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily incident counts for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const incidents = await maestroProcesses.getIncidentsTimeline(sevenDaysAgo, now);
+     *
+     * for (const incident of incidents) {
+     *   console.log(`${incident.startTime} → ${incident.endTime}: ${incident.count} incidents`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/maestro-processes';
+     *
+     * // Get weekly breakdown
+     * const incidents = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter to a specific process
+     * const filtered = await maestroProcesses.getIncidentsTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<IncidentTimelineResponse[]>;
     /**
      * Get the top 10 processes ranked by failure count within a time range.
      *
@@ -6354,32 +7192,75 @@ declare class MaestroProcessesService extends BaseService implements MaestroProc
      * Returns per-element execution counts (success, fail, terminated, paused, in-progress) and
      * duration percentile metrics (min, max, avg, p50, p95, p99) for BPMN elements within a process.
      *
-     * @param processKey - Process key to filter by
-     * @param packageId - Package identifier
-     * @param startTime - Start of the time range to query
-     * @param endTime - End of the time range to query
-     * @param packageVersion - Package version to filter by
+     * @param request - Process scope + time range to aggregate over
      * @returns Promise resolving to an array of {@link ElementStats}
      * @example
      * ```typescript
-     * // Get element metrics for a process
-     * const elements = await maestroProcesses.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get element metrics for that process
+     * const elements = await maestroProcesses.getElementStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * // Analyze element performance
+     * for (const element of elements) {
+     *   console.log(`Element: ${element.elementId}`);
+     *   console.log(`  Success: ${element.successCount}, Failed: ${element.failCount}`);
+     *   console.log(`  Avg duration: ${element.avgDurationMs}ms, P95: ${element.p95DurationMs}ms`);
+     * }
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundElements = await process.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   process.packageVersions[0]
+     * );
+     * ```
+     */
+    getElementStats(request: MaestroProcessStatsRequest): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for a process.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a process within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list processes to find the processKey, packageId, and available versions
+     * const processes = await maestroProcesses.getAll();
+     * const process = processes[0];
+     *
+     * // Get instance status breakdown for that process
+     * const counts = await maestroProcesses.getInstanceStats({
+     *   processKey: process.processKey,
+     *   packageId: process.packageId,
+     *   packageVersion: process.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Running: ${counts.runningCount}, Completed: ${counts.completedCount}`);
+     * console.log(`Faulted: ${counts.faultedCount}, Avg duration: ${counts.avgDurationMs}ms`);
+     *
+     * // Using bound method on a process — auto-fills processKey and packageId
+     * const boundCounts = await process.getInstanceStats(
      *   new Date('2026-04-01'),
      *   new Date(),
-     *   '1.0.1'
+     *   process.packageVersions[0]
      * );
-     *
-     * // Analyze element performance
-     * for (const element of elements) {
-     *   console.log(`Element: ${element.elementId}`);
-     *   console.log(`  Success: ${element.successCount}, Failed: ${element.failCount}`);
-     *   console.log(`  Avg duration: ${element.avgDurationMs}ms, P95: ${element.p95DurationMs}ms`);
-     * }
      * ```
      */
-    getElementStats(processKey: string, packageId: string, startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    getInstanceStats(request: MaestroProcessStatsRequest): Promise<InstanceStats>;
 }
 
 declare class ProcessInstancesService extends BaseService implements ProcessInstancesServiceModel {
@@ -6425,7 +7306,7 @@ declare class ProcessInstancesService extends BaseService implements ProcessInst
      */
     getAll<T extends ProcessInstanceGetAllWithPaginationOptions = ProcessInstanceGetAllWithPaginationOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ProcessInstanceGetResponse> : NonPaginatedResponse<ProcessInstanceGetResponse>>;
     /**
-     * Get a process instance by ID with operation methods (cancel, pause, resume)
+     * Get a process instance by ID with operation methods (cancel, pause, resume, retry)
      * @param id The ID of the instance to retrieve
      * @param folderKey The folder key for authorization
      * @returns Promise<ProcessInstanceGetResponse>
@@ -6486,6 +7367,17 @@ declare class ProcessInstancesService extends BaseService implements ProcessInst
      * @returns Promise resolving to operation result with updated instance data
      */
     resume(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
+    /**
+     * Retry a faulted process instance
+     *
+     * Re-runs the failed elements of the instance (and the elements that follow) within
+     * the same instance, spawning new jobs. Use to recover from transient/flaky failures.
+     * @param instanceId The ID of the instance to retry
+     * @param folderKey The folder key for authorization
+     * @param options Optional retry options with comment
+     * @returns Promise resolving to operation result with updated instance data
+     */
+    retry(instanceId: string, folderKey: string, options?: ProcessInstanceOperationOptions): Promise<OperationResponse<ProcessInstanceOperationResponse>>;
     /**
      * Parses BPMN XML to extract variable metadata from uipath:inputOutput elements
      * @private
@@ -6662,7 +7554,7 @@ declare class CasesService extends BaseService implements CasesServiceModel {
      *
      * @param startTime - Start of the time range to query
      * @param endTime - End of the time range to query
-     * @param options - Optional settings for time bucketing granularity
+     * @param options - Optional settings for filtering and time bucket granularity
      * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
      *
      * @example
@@ -6689,11 +7581,62 @@ declare class CasesService extends BaseService implements CasesServiceModel {
      *
      * @example
      * ```typescript
+     * // Filter to a specific case process
+     * const filtered = await cases.getInstanceStatusTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
      * // Get all-time data (from Unix epoch to now)
      * const allTime = await cases.getInstanceStatusTimeline(new Date(0), new Date());
      * ```
      */
     getInstanceStatusTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<InstanceStatusTimelineResponse[]>;
+    /**
+     * Get incident counts aggregated by time bucket for case management processes.
+     *
+     * Returns time-grouped counts of incidents that occurred within each bucket,
+     * useful for rendering incident time-series charts. Use `groupBy` to control
+     * the time bucket size (hour, day, or week) — defaults to day if not provided.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional settings for filtering and time bucket granularity
+     * @returns Promise resolving to an array of {@link IncidentTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily incident counts for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const incidents = await cases.getIncidentsTimeline(sevenDaysAgo, now);
+     *
+     * for (const incident of incidents) {
+     *   console.log(`${incident.startTime} → ${incident.endTime}: ${incident.count} incidents`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/cases';
+     *
+     * // Get weekly breakdown
+     * const incidents = await cases.getIncidentsTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter to a specific case process
+     * const filtered = await cases.getIncidentsTimeline(startTime, endTime, {
+     *   processKeys: ['<processKey>'],
+     * });
+     * ```
+     */
+    getIncidentsTimeline(startTime: Date, endTime: Date, options?: TimelineOptions): Promise<IncidentTimelineResponse[]>;
     /**
      * Get the top 10 case processes ranked by failure count within a time range.
      *
@@ -6776,31 +7719,73 @@ declare class CasesService extends BaseService implements CasesServiceModel {
      * Returns per-element execution counts (success, fail, terminated, paused, in-progress) and
      * duration percentile metrics (min, max, avg, p50, p95, p99) for BPMN elements within a case.
      *
-     * @param processKey - Process key to filter by
-     * @param packageId - Package identifier
-     * @param startTime - Start of the time range to query
-     * @param endTime - End of the time range to query
-     * @param packageVersion - Package version to filter by
+     * @param request - Process scope + time range to aggregate over
      * @returns Promise resolving to an array of {@link ElementStats}
      * @example
      * ```typescript
-     * // Get element metrics for a case
-     * const elements = await cases.getElementStats(
-     *   '<processKey>',
-     *   '<packageId>',
-     *   new Date('2026-04-01'),
-     *   new Date(),
-     *   '1.0.1'
-     * );
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get element metrics for that case
+     * const elements = await cases.getElementStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
      *
      * // Find elements with failures
      * const failedElements = elements.filter(e => e.failCount > 0);
      * for (const element of failedElements) {
      *   console.log(`Failed element: ${element.elementId}, failures: ${element.failCount}`);
      * }
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundElements = await caseItem.getElementStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.packageVersions[0]
+     * );
      * ```
      */
-    getElementStats(processKey: string, packageId: string, startTime: Date, endTime: Date, packageVersion: string): Promise<ElementStats[]>;
+    getElementStats(request: MaestroProcessStatsRequest): Promise<ElementStats[]>;
+    /**
+     * Get instance stats for a case.
+     *
+     * Returns total instance counts broken down by status (running, completed, faulted, etc.)
+     * and the average execution duration for all instances of a case within a time range.
+     *
+     * @param request - Process scope + time range to aggregate over
+     * @returns Promise resolving to {@link InstanceStats}
+     * @example
+     * ```typescript
+     * // First, list cases to find the processKey, packageId, and available versions
+     * const allCases = await cases.getAll();
+     * const caseItem = allCases[0];
+     *
+     * // Get instance status breakdown for that case
+     * const counts = await cases.getInstanceStats({
+     *   processKey: caseItem.processKey,
+     *   packageId: caseItem.packageId,
+     *   packageVersion: caseItem.packageVersions[0],
+     *   startTime: new Date('2026-04-01'),
+     *   endTime: new Date(),
+     * });
+     *
+     * console.log(`Total: ${counts.totalCount}`);
+     * console.log(`Completed: ${counts.completedCount}, Faulted: ${counts.faultedCount}`);
+     *
+     * // Using bound method on a case — auto-fills processKey and packageId
+     * const boundCounts = await caseItem.getInstanceStats(
+     *   new Date('2026-04-01'),
+     *   new Date(),
+     *   caseItem.packageVersions[0]
+     * );
+     * ```
+     */
+    getInstanceStats(request: MaestroProcessStatsRequest): Promise<InstanceStats>;
     /**
      * Extract a readable case name from the packageId
      * @param packageId - The full package identifier
@@ -7058,6 +8043,14 @@ declare class CaseInstancesService extends BaseService implements CaseInstancesS
     getStagesSlaSummary(options?: CaseInstanceStageSLAOptions): Promise<CaseInstanceStageSLAResponse[]>;
 }
 
+/**
+ * Type for field mapping configuration
+ * Maps source field names to target field names
+ */
+type FieldMapping = {
+    [sourceField: string]: string;
+};
+
 /**
  * Base service for services that need folder-specific functionality.
  *
@@ -7099,9 +8092,12 @@ declare class FolderScopedService extends BaseService {
      * @param name - Resource name to search for
      * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) + OData query options (`expand`, `select`)
      * @param transform - Maps a raw OData item to the typed response (e.g. PascalCase → camelCase via field map)
+     * @param responseFieldMap - Optional response field map (API → SDK), reversed internally by
+     *   `transformOptions` to rewrite SDK field names back to API names in user-supplied
+     *   `expand` / `select` (symmetric counterpart to `transform`)
      * @throws ValidationError when inputs are malformed; NotFoundError when no match
      */
-    protected getByNameLookup<TRaw extends object, T>(resourceType: string, endpoint: string, name: string, options: FolderScopedOptions, transform: (raw: TRaw) => T): Promise<T>;
+    protected getByNameLookup<TRaw extends object, T>(resourceType: string, endpoint: string, name: string, options: FolderScopedOptions, transform: (raw: TRaw) => T, responseFieldMap?: FieldMapping): Promise<T>;
 }
 
 /**
@@ -8525,6 +9521,8 @@ interface ProcessStartResponse extends ProcessProperties, FolderProperties {
     createdTime: string;
     startingScheduleId: number | null;
     processName: string;
+    /** Key of the process this job was started from. */
+    processKey: string;
     type: JobType;
     inputFile: string | null;
     outputArguments: string | null;
@@ -8824,8 +9822,9 @@ interface JobServiceModel {
      * const folderJobs = await jobs.getAll({ folderId: <folderId> });
      *
      * // With filtering
-     * const runningJobs = await jobs.getAll({
-     *   filter: "state eq 'Running'"
+     * const recentInvoiceJobs = await jobs.getAll({
+     *   filter: "processName eq 'InvoiceBot'",
+     *   orderby: 'createdTime desc',
      * });
      *
      * // First page with pagination
@@ -9974,6 +10973,18 @@ declare class UiPath extends UiPath$1 {
          * Access to ChoiceSet service for managing choice sets
          */
         choicesets: ChoiceSetService;
+        /**
+         * Access to Data Fabric roles for manage-access flows
+         *
+         * @internal
+         */
+        roles: DataFabricRoleService;
+        /**
+         * Access to Data Fabric directory principals and role assignments
+         *
+         * @internal
+         */
+        directory: DataFabricDirectoryService;
     };
     /**
      * Access to Tasks service
@@ -11104,6 +12115,16 @@ interface SessionEndingEvent {
      */
     timeToLiveMS: number;
 }
+/**
+ * A client-side tool that the client supports, declared during exchange start
+ * so the server knows which tools to route client-side.
+ * @internal
+ */
+interface ClientSideTool {
+    name: string;
+    inputSchema?: JSONValue;
+    outputSchema?: JSONValue;
+}
 /**
  * Signals the start of an exchange of messages within a conversation.
  */
@@ -11120,6 +12141,12 @@ interface ExchangeStartEvent {
      * The time the exchange started.
      */
     timestamp?: string;
+    /**
+     * Optional list of client-side tools the client supports. The server validates these against the agent's
+     * design-time definitions and forwards them to the runtime so it knows which tools to route client-side.
+     * @internal
+     */
+    clientSideTools?: ClientSideTool[];
 }
 /**
  * Signals the end of an exchange of messages within a conversation.
@@ -11373,6 +12400,16 @@ interface ToolCallStartEvent {
      * `requireConfirmation` is true so the client can render an editable form.
      */
     inputSchema?: JSONValue;
+    /**
+     * Output schema — used by the client to render the result form for client-side tools.
+     * @internal
+     */
+    outputSchema?: JSONValue;
+    /**
+     * Indicates this tool call should be executed client-side rather than server-side.
+     * @internal
+     */
+    isClientSideTool?: boolean;
 }
 /**
  * Sent by the client to approve or reject a tool call that was emitted with
@@ -11415,6 +12452,20 @@ interface ToolCallEndEvent {
      */
     metaData?: MetaData;
 }
+/**
+ * Signals to the client that the tool is about to be executed. Emitted in all scenarios
+ * (server-side and client-side tools). For client-side tools, the client should begin
+ * executing its registered handler upon receiving this event.
+ * @internal
+ */
+interface ExecutingToolCallEvent {
+    /**
+     * The time the tool call began executing.
+     */
+    timestamp?: string;
+    /** The final tool input, reflecting any modifications made during tool-call confirmation. */
+    input?: ToolCallInputValue;
+}
 /**
  * Allows additional events to be sent in the context of the enclosing event stream.
  */
@@ -11455,6 +12506,12 @@ interface ToolCallEvent {
      * emitted with `requireConfirmation: true`.
      */
     confirmToolCall?: ToolCallConfirmationEvent;
+    /**
+     * Signals that the tool is about to be executed. For client-side tools,
+     * the client should begin executing its handler upon receiving this event.
+     * @internal
+     */
+    executingToolCall?: ExecutingToolCallEvent;
     /**
      * Allows additional events to be sent in the context of the enclosing event stream.
      */
@@ -12133,6 +13190,19 @@ type CompletedToolCall = ToolCallStartEvent & ToolCallEndEvent & {
  *   }
  * });
  * ```
+ *
+ * @example Handling client-side tool execution
+ * ```typescript
+ * message.onToolCallStart((toolCall) => {
+ *   const { isClientSideTool, toolName } = toolCall.startEvent;
+ *   if (!isClientSideTool) return;
+ *
+ *   toolCall.onExecutingToolCall(async (event) => {
+ *     const result = await runLocalProcess(toolName, event.input);
+ *     toolCall.sendToolCallEnd({ output: result });
+ *   });
+ * });
+ * ```
  */
 interface ToolCallStream {
     /** Unique identifier for this tool call */
@@ -12204,6 +13274,24 @@ interface ToolCallStream {
      * ```
      */
     onToolCallConfirm(callback: (confirmToolCall: ToolCallConfirmationEvent) => void): () => void;
+    /**
+     * Registers a handler for executingToolCall events. Fired when the tool is about
+     * to be executed. For client-side tools, the client should begin executing its
+     * handler upon receiving this event.
+     *
+     * @param cb - Callback receiving the executing event
+     * @returns Cleanup function to remove the handler
+     *
+     * @example Handling client-side tool execution
+     * ```typescript
+     * toolCall.onExecutingToolCall(async (event) => {
+     *   const result = await executeLocally(toolCall.startEvent.toolName, event.input);
+     *   toolCall.sendToolCallEnd({ output: result });
+     * });
+     * ```
+     * @internal
+     */
+    onExecutingToolCall(cb: (event: ExecutingToolCallEvent) => void): () => void;
     /**
      * Ends the tool call
      *
@@ -13235,12 +14323,23 @@ interface ExchangeStream {
      */
     getMessage(messageId: string): MessageStream | undefined;
     /**
-     * Ends the exchange
+     * Ends the exchange. Stops further events for that exchange from being received.
+     * Use this to stop an in-progress agent response from the client side.
      *
      * @param endExchange - Optional end event data
      *
-     * @example Manually ending an exchange
+     * @example Manually ending an exchange and stopping a response mid-stream
+     * ```typescript
+     * session.onExchangeStart((exchange) => {
+     *   stopButton.addEventListener('click', () => exchange.sendExchangeEnd());
+     * });
+     * ```
+     *
+     * @example End an exchange after sending a message
      * ```typescript
+     * const exchange = session.startExchange();
+     * exchange.sendMessageWithContentPart({ data: 'Hello!' });
+     * // Later, stop the response
      * exchange.sendExchangeEnd();
      * ```
      */
@@ -15047,6 +16146,7 @@ type FeatureFlags = Record<string, unknown>;
  *     S -->|onExchangeStart| E["ExchangeStream"]
  *     S -->|onSessionEnd| SE(["session closed"])
  *     E -->|onMessageStart| M["MessageStream"]
+ *     E -->|sendExchangeEnd| STOP(["stop response"])
  *     E -->|onExchangeEnd| EE(["exchange complete"])
  *     M -->|onContentPartStart| CP["ContentPartStream"]
  *     M -->|onToolCallStart| TC["ToolCallStream"]
@@ -15090,10 +16190,20 @@ type FeatureFlags = Record<string, unknown>;
  *   exchange.sendMessageWithContentPart({ data: 'Hello!' });
  * });
  *
- * // 5. End session when done
+ * // 5. Stop a response mid-stream
+ * // Use sendExchangeEnd() on any active exchange to stop the agent
+ * session.onSessionStarted(() => {
+ *   const exchange = session.startExchange();
+ *   exchange.sendMessageWithContentPart({ data: 'Tell me a long story' });
+ *
+ *   // Stop after 5 seconds
+ *   setTimeout(() => exchange.sendExchangeEnd(), 5000);
+ * });
+ *
+ * // 6. End session when done
  * conversation.endSession();
  *
- * // 6. Retrieve conversation history (offline)
+ * // 7. Retrieve conversation history (offline)
  * const exchanges = await conversation.exchanges.getAll();
  * ```
  */
@@ -15638,9 +16748,9 @@ declare enum AgentListSortColumn {
     HealthScore = "HealthScore",
     LastIncident = "LastIncident",
     FolderName = "FolderName",
-    /** Quantity of AGU (Agent Units) consumed */
+    /** Quantity of Agent Units consumed */
     QuantityAGU = "QuantityAGU",
-    /** Quantity of PLTU (Platform Units) consumed */
+    /** Quantity of Platform Units consumed */
     QuantityPLTU = "QuantityPLTU",
     FolderPath = "FolderPath"
 }
@@ -15650,7 +16760,10 @@ declare enum AgentListSortColumn {
 interface AgentListOrderBy {
     /** Column to sort by */
     column: AgentListSortColumn;
-    /** Sort descending. Defaults to false. */
+    /**
+     * Sort descending.
+     * @default false
+     */
     desc?: boolean;
 }
 /**
@@ -15684,9 +16797,9 @@ interface AgentListItem {
     unitsQuantity: number;
     /** Display name of the units (if any). May be `null` or `""`. */
     unitsName: string | null;
-    /** Quantity of AGU (Agent Units) consumed by this agent */
+    /** Quantity of Agent Units consumed by this agent */
     quantityAGU: number;
-    /** Quantity of PLTU (Platform Units) consumed by this agent */
+    /** Quantity of Platform Units consumed by this agent */
     quantityPLTU: number;
 }
 /**
@@ -15741,7 +16854,10 @@ declare enum AgentErrorSortColumn {
 interface AgentErrorOrderBy {
     /** Column to sort by */
     column: AgentErrorSortColumn;
-    /** Sort descending. Defaults to false (ascending) server-side. */
+    /**
+     * Sort descending.
+     * @default false
+     */
     desc?: boolean;
 }
 /**
@@ -15802,40 +16918,333 @@ interface AgentGetErrorsTimelineResponse {
  * Options for getting the agent errors timeline.
  */
 interface AgentGetErrorsTimelineOptions extends AgentFilterOptions {
-    /** Max number of agents to return. Defaults to 10 server-side. */
+    /**
+     * Max number of agents to return.
+     * @default 10
+     */
+    limit?: number;
+}
+/**
+ * A single point on the agent consumption timeline
+ */
+interface AgentGetConsumptionTimelineResponse {
+    /** Bucket timestamp (ISO 8601, UTC) */
+    timeSlice: string;
+    /** Agent Units quantity consumed in this time bucket */
+    aguConsumption: number;
+}
+/**
+ * Options for getting the agent consumption timeline.
+ */
+interface AgentGetConsumptionTimelineOptions extends AgentFilterOptions {
+}
+/**
+ * A single point on the agent latency timeline
+ */
+interface AgentGetLatencyTimelineResponse {
+    /**
+     * Percentile label for this point — observed values: `"P50"`, `"P95"`.
+     */
+    name: string;
+    /** Latency value in milliseconds. */
+    value: number;
+    /** Bucket timestamp (ISO 8601, UTC) */
+    date: string;
+}
+/**
+ * Options for getting the agent latency timeline.
+ */
+interface AgentGetLatencyTimelineOptions extends AgentFilterOptions {
+}
+/**
+ * A single agent's error count over the requested window, with the first and
+ * last jobs where errors were observed.
+ */
+interface AgentTopErrorCount {
+    /** Agent name */
+    name: string;
+    /** Error count for this agent over the requested window */
+    count: number;
+    /** Agent ID (GUID) */
+    agentId: string;
+    /** First job in the window where this agent reported errors */
+    firstSeenJob: AgentJobInfo;
+    /** Last job in the window where this agent reported errors */
+    lastSeenJob: AgentJobInfo;
+}
+/**
+ * Response from getting the top agents by error count.
+ */
+interface AgentGetTopErrorCountResponse {
+    /** Total error count across all agents in the window. */
+    totalErrors: number;
+    /** Top-N agents ranked by error count. */
+    data: AgentTopErrorCount[];
+}
+/**
+ * Options for getting the top agents by error count.
+ */
+interface AgentGetTopErrorCountOptions extends AgentFilterOptions {
+    /**
+     * Max number of agents to return. Defaults to 10 server-side.
+     * @default 10
+     */
+    limit?: number;
+}
+/**
+ * Agent type, used to filter consumption results.
+ *
+ * Wire format is the string name, per the API's `StringEnumConverter` serialization.
+ */
+declare enum AgentType {
+    Autonomous = "Autonomous",
+    Conversational = "Conversational",
+    Coded = "Coded"
+}
+/**
+ * A single agent's unit consumption over the requested window, with the first
+ * and last jobs where consumption was recorded.
+ */
+interface AgentConsumption {
+    /** Agent ID (GUID) */
+    agentId: string;
+    /** Agent display name */
+    agentName: string;
+    /** Total quantity consumed by this agent. `null` if no consumption is recorded. */
+    consumedQuantity: number | null;
+    /** Agent Units quantity consumed. `null` if no consumption is recorded. */
+    consumedAGUQuantity: number | null;
+    /** Platform Units quantity consumed. `null` if no consumption is recorded. */
+    consumedPLTUQuantity: number | null;
+    /** First job in the window where this agent recorded consumption */
+    firstSeenJob: AgentJobInfo;
+    /** Last job in the window where this agent recorded consumption */
+    lastSeenJob: AgentJobInfo;
+}
+/**
+ * Response from getting the top agents by consumption.
+ */
+interface AgentGetTopConsumptionResponse {
+    /** Window start date. */
+    startDate: string;
+    /** Window end date. */
+    endDate: string;
+    /** Total quantity consumed across all matching agents in the window. */
+    totalConsumed: number;
+    /** Total Agent Units quantity consumed. */
+    totalAGUConsumed: number;
+    /** Total Platform Units quantity consumed. */
+    totalPLTUConsumed: number;
+    /** Limit applied (echoed from the request). */
+    limit: number;
+    /** Top-N agents ranked by consumption. Empty array when no agents matched. */
+    agents: AgentConsumption[];
+}
+/**
+ * Options for getting the top agents by consumption.
+ */
+interface AgentGetTopConsumptionOptions extends AgentFilterOptions {
+    /**
+     * Max number of agents to return. Defaults to 10 server-side.
+     * @default 10
+     */
     limit?: number;
+    /**
+     * Health-based filter. `true` returns only healthy agents, `false` only
+     * unhealthy. Omit to include both.
+     */
+    healthy?: boolean;
+    /**
+     * Health-score cutoff used when `healthy` is set. Defaults to 75.0
+     * server-side.
+     * @default 75.0
+     */
+    healthThreshold?: number;
+    /**
+     * Filter to specific agent types. Multiple types are combined with `OR` and
+     * sent to the API as a comma-separated string.
+     */
+    agentTypes?: AgentType[];
+}
+/**
+ * Distribution of incidents across types over the requested window.
+ */
+interface AgentGetIncidentDistributionResponse {
+    /** Number of error-type incidents in the window */
+    errorCount: number;
+    /** Number of escalation-type incidents in the window */
+    escalationCount: number;
+    /** Number of policy-type incidents in the window */
+    policyCount: number;
+}
+/**
+ * Options for getting the incident distribution.
+ *
+ * Currently identical to {@link AgentFilterOptions}; named distinctly so that
+ * future per-method filters can be added without a breaking change.
+ */
+interface AgentGetIncidentDistributionOptions extends AgentFilterOptions {
+}
+/**
+ * Per-agent (process + folder) stats within an {@link AgentSummaryPeriod}.
+ */
+interface AgentSummaryEntry {
+    /** Process key (GUID) */
+    processKey: string;
+    /** Folder key (GUID) the agent ran in */
+    folderKey: string;
+    /** Process version */
+    processVersion: string;
+    /** Total job runs in the period */
+    totalJobs: number;
+    /** Number of successful runs in the period */
+    successfulJobs: number;
+    /** Success rate as a percentage (0-100) */
+    successRate: number;
+    /** Average run duration in seconds */
+    averageDurationSeconds: number;
+    /** First job completion timestamp (ISO 8601, UTC) */
+    firstJobFinished: string;
+    /** Last job completion timestamp (ISO 8601, UTC) */
+    lastJobFinished: string;
+    /**
+     * Status of the most recent run, normalized to {@link JobState}. The API's
+     * `Success` label maps to {@link JobState.Successful}; any unrecognized value
+     * becomes {@link JobState.Unknown}.
+     */
+    lastJobStatus: JobState;
+}
+/**
+ * Aggregate stats for a single period within an {@link AgentGetSummaryResponse}
+ * — covers the requested window for either the current period or an optional
+ * lookback period.
+ */
+interface AgentSummaryPeriod {
+    /** Total job runs across all agents in the period */
+    totalJobs: number;
+    /** Number of successful runs across all agents in the period */
+    successfulJobs: number;
+    /** Overall success rate as a percentage (0-100) */
+    successRate: number;
+    /** Average run duration in seconds across all agents in the period */
+    averageDurationSeconds: number;
+    /** Period start time (ISO 8601, UTC) */
+    startTime: string;
+    /** Period end time (ISO 8601, UTC) */
+    endTime: string;
+    /** Per-agent breakdown */
+    agents: AgentSummaryEntry[];
+}
+/**
+ * Response from getting the agent summary.
+ */
+interface AgentGetSummaryResponse {
+    /** Aggregate stats for the requested window. Always present. */
+    currentPeriodSummary: AgentSummaryPeriod;
+    /** Aggregate stats for the prior window of equal length. Only present when `lookbackPeriodAnalysis: true` was sent. */
+    lookbackPeriodSummary?: AgentSummaryPeriod;
+}
+/**
+ * Job execution mode filter accepted by the summary endpoints.
+ *
+ * Wire format is the string name (`"Debug"` / `"Runtime"`), per the API's
+ * `StringEnumConverter` serialization.
+ */
+declare enum AgentExecutionType {
+    /** Test runs */
+    Debug = "Debug",
+    /** Production runs */
+    Runtime = "Runtime"
+}
+/**
+ * Options for getting the agent summary.
+ */
+interface AgentGetSummaryOptions extends AgentFilterOptions {
+    /**
+     * When `true`, it also computes a `lookbackPeriodSummary` for the
+     * prior window of equal length. Defaults to `false` server-side.
+     * @default false
+     */
+    lookbackPeriodAnalysis?: boolean;
+    /** Filter to a specific process by key (GUID). */
+    processKey?: string;
+    /**
+     * Filter to a specific folder by key (GUID).
+     *
+     * The summary endpoint accepts both — `folderKey` selects a
+     * single folder, `folderKeys` filters the lookup to a list of folders.
+     */
+    folderKey?: string;
+    /**
+     * Filter to a specific execution type — `Debug` (test runs) or
+     * `Runtime` (production runs).
+     */
+    executionType?: AgentExecutionType;
 }
 /**
- * A single point on the agent consumption timeline
+ * Job-type breakdown of unit consumption — completed jobs vs jobs still in
+ * progress at query time.
  */
-interface AgentGetConsumptionTimelineResponse {
-    /** Bucket timestamp (ISO 8601, UTC) */
-    timeSlice: string;
-    /** AGU quantity consumed in this time bucket */
-    aguConsumption: number;
+interface AgentJobConsumptionSummary {
+    /** Units consumed by jobs that have completed in the period */
+    completeJobs: number;
+    /** Units consumed by jobs still in progress at query time */
+    incompleteJobs: number;
 }
 /**
- * Options for getting the agent consumption timeline.
+ * Per-agent (process + folder) unit consumption entry within an
+ * {@link AgentUnitConsumptionPeriod}.
  */
-interface AgentGetConsumptionTimelineOptions extends AgentFilterOptions {
+interface AgentUnitConsumptionEntry {
+    /** Folder key (GUID) the agent ran in */
+    folderKey: string;
+    /** Process key (GUID) */
+    processKey: string;
+    /** Process version */
+    processVersion: string;
+    /** First job completion timestamp (ISO 8601). `"0001-01-01T00:00:00"` if no completion in the period. */
+    firstJobFinished: string;
+    /** Last job completion timestamp (ISO 8601). `"0001-01-01T00:00:00"` if no completion in the period. */
+    lastJobFinished: string;
+    /** Agent Units consumption for this agent, split by job completion status */
+    agentUnitConsumption: AgentJobConsumptionSummary;
+    /** Platform Units consumption for this agent, split by job completion status */
+    platformUnitConsumption: AgentJobConsumptionSummary;
+}
+/**
+ * Aggregate Agent Units and Platform Units consumption for a single period within an
+ * {@link AgentGetUnitConsumptionSummaryResponse} — covers the requested window
+ * for either the current period or an optional lookback period.
+ */
+interface AgentUnitConsumptionPeriod {
+    /** Total Agent Units consumed across all agents in the period, split by job completion */
+    totalAgentUnitConsumption: AgentJobConsumptionSummary;
+    /** Total Platform Units consumed across all agents in the period, split by job completion */
+    totalPlatformUnitConsumption: AgentJobConsumptionSummary;
+    /** Period start time (ISO 8601, UTC) */
+    startTime: string;
+    /** Period end time (ISO 8601, UTC) */
+    endTime: string;
+    /** Per-agent consumption breakdown */
+    agentConsumption: AgentUnitConsumptionEntry[];
 }
 /**
- * A single point on the agent latency timeline
+ * Response from getting the agent unit consumption summary.
  */
-interface AgentGetLatencyTimelineResponse {
-    /**
-     * Percentile label for this point — observed values: `"P50"`, `"P95"`.
-     */
-    name: string;
-    /** Latency value in milliseconds. */
-    value: number;
-    /** Bucket timestamp (ISO 8601, UTC) */
-    date: string;
+interface AgentGetUnitConsumptionSummaryResponse {
+    /** Aggregate consumption for the requested window. Always present. */
+    currentPeriodSummary: AgentUnitConsumptionPeriod;
+    /** Aggregate consumption for the prior window of equal length. Only present when `lookbackPeriodAnalysis: true` was sent. */
+    lookbackPeriodSummary?: AgentUnitConsumptionPeriod;
 }
 /**
- * Options for getting the agent latency timeline.
+ * Options for getting the agent unit consumption summary.
+ *
+ * Currently identical to {@link AgentGetSummaryOptions} (the API uses the same
+ * `AgentsSummaryRequest` schema for both endpoints); named distinctly so that
+ * future per-method filters can be added without a breaking change.
  */
-interface AgentGetLatencyTimelineOptions extends AgentFilterOptions {
+interface AgentGetUnitConsumptionSummaryOptions extends AgentGetSummaryOptions {
 }
 
 /**
@@ -15978,7 +17387,7 @@ interface AgentServiceModel {
      */
     getErrorsTimeline(startTime: Date, endTime: Date, options?: AgentGetErrorsTimelineOptions): Promise<AgentGetErrorsTimelineResponse[]>;
     /**
-     * Retrieves a time-series of AGU (Agent Units) consumption over the requested window.
+     * Retrieves a time-series of Agent Units consumption over the requested window.
      *
      * @param startTime - Inclusive lower bound for the query window
      * @param endTime - Exclusive upper bound for the query window
@@ -15990,13 +17399,13 @@ interface AgentServiceModel {
      *
      * const agents = new Agents(sdk);
      *
-     * // AGU consumption timeline in May 2025
+     * // Agent Units consumption timeline in May 2025
      * const result = await agents.getConsumptionTimeline(
      *   new Date('2025-05-01T00:00:00Z'),
      *   new Date('2025-06-01T00:00:00Z'),
      * );
      * result.forEach((point) => {
-     *   console.log(`${point.timeSlice}: ${point.aguConsumption} AGU`);
+     *   console.log(`${point.timeSlice}: ${point.aguConsumption} Agent Units`);
      * });
      * ```
      * @example
@@ -16050,6 +17459,198 @@ interface AgentServiceModel {
      * ```
      */
     getLatencyTimeline(startTime: Date, endTime: Date, options?: AgentGetLatencyTimelineOptions): Promise<AgentGetLatencyTimelineResponse[]>;
+    /**
+     * Retrieves the top-N agents ranked by error count over the requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetTopErrorCountResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top agents by error count in May 2025
+     * const result = await agents.getTopErrorCount(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * result.data.forEach((agent) => {
+     *   console.log(`${agent.name}: ${agent.count} errors`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * // Scope to specific folders and top 5 agents
+     * const result = await agents.getTopErrorCount(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     folderKeys: ['<folderKey1>'],
+     *     limit: 5,
+     *   },
+     * );
+     * ```
+     */
+    getTopErrorCount(startTime: Date, endTime: Date, options?: AgentGetTopErrorCountOptions): Promise<AgentGetTopErrorCountResponse>;
+    /**
+     * Retrieves the top-N agents ranked by unit consumption over the requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetTopConsumptionResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top agents by consumption in May 2025
+     * const result = await agents.getTopConsumption(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Total consumed: ${result.totalConsumed}`);
+     * result.agents.forEach((agent) => {
+     *   console.log(`${agent.agentName}: ${agent.consumedQuantity}`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Top 5 healthy autonomous agents by consumption
+     * const result = await agents.getTopConsumption(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     limit: 5,
+     *     healthy: true,
+     *     agentTypes: [AgentType.Autonomous],
+     *   },
+     * );
+     * ```
+     */
+    getTopConsumption(startTime: Date, endTime: Date, options?: AgentGetTopConsumptionOptions): Promise<AgentGetTopConsumptionResponse>;
+    /**
+     * Retrieves breakdown of agent incidents count — errors, escalations,
+     * and policy violations over a requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetIncidentDistributionResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Incident distribution in May 2025
+     * const result = await agents.getIncidentDistribution(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Errors: ${result.errorCount}, Escalations: ${result.escalationCount}, Policy: ${result.policyCount}`);
+     * ```
+     * @example
+     * ```typescript
+     * // Scope to specific folders
+     * const result = await agents.getIncidentDistribution(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     folderKeys: ['<folderKey1>'],
+     *   },
+     * );
+     * ```
+     */
+    getIncidentDistribution(startTime: Date, endTime: Date, options?: AgentGetIncidentDistributionOptions): Promise<AgentGetIncidentDistributionResponse>;
+    /**
+     * Retrieves a job-execution summary for the requested window: overall totals
+     * (total jobs, successful jobs, success rate, average duration) alongside a
+     * per-agent breakdown. When `lookbackPeriodAnalysis` is enabled, a comparable
+     * summary for the preceding window of equal length is included too.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetSummaryResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Summary for May 2025
+     * const result = await agents.getSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Success rate: ${result.currentPeriodSummary.successRate}%`);
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentExecutionType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Runtime-only summary with lookback comparison
+     * const result = await agents.getSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     lookbackPeriodAnalysis: true,
+     *     executionType: AgentExecutionType.Runtime,
+     *   },
+     * );
+     * ```
+     */
+    getSummary(startTime: Date, endTime: Date, options?: AgentGetSummaryOptions): Promise<AgentGetSummaryResponse>;
+    /**
+     * Retrieves an aggregate Agent Units and Platform Units consumption summary per agent over the
+     * requested window.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param endTime - Exclusive upper bound for the query window
+     * @param options - Optional filters
+     * @returns Promise resolving to {@link AgentGetUnitConsumptionSummaryResponse}
+     * @example
+     * ```typescript
+     * import { Agents } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Unit consumption summary for May 2025
+     * const result = await agents.getUnitConsumptionSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     * );
+     * console.log(`Agent Units complete jobs: ${result.currentPeriodSummary.totalAgentUnitConsumption.completeJobs}`);
+     * ```
+     * @example
+     * ```typescript
+     * import { Agents, AgentExecutionType } from '@uipath/uipath-typescript/agents';
+     *
+     * const agents = new Agents(sdk);
+     *
+     * // Runtime-only summary with lookback comparison
+     * const result = await agents.getUnitConsumptionSummary(
+     *   new Date('2025-05-01T00:00:00Z'),
+     *   new Date('2025-06-01T00:00:00Z'),
+     *   {
+     *     lookbackPeriodAnalysis: true,
+     *     executionType: AgentExecutionType.Runtime,
+     *   },
+     * );
+     * ```
+     */
+    getUnitConsumptionSummary(startTime: Date, endTime: Date, options?: AgentGetUnitConsumptionSummaryOptions): Promise<AgentGetUnitConsumptionSummaryResponse>;
 }
 
 /**
@@ -16099,7 +17700,10 @@ interface AgentMemoryGetCallsTimelineOptions extends AgentMemoryFilterOptions {
  * Options for retrieving the top memory spaces.
  */
 interface AgentMemoryGetTopSpacesOptions extends AgentMemoryFilterOptions {
-    /** Maximum number of memory spaces to return, ranked by memory count. Defaults to 5 when omitted. */
+    /**
+     * Maximum number of memory spaces to return, ranked by memory count.
+     * @default 5
+     */
     limit?: number;
 }
 /**
@@ -17597,7 +19201,7 @@ interface AgentTraceGetLatencyTimelineOptions extends AgentTraceFilterOptions {
 }
 /**
  * Per-agent unit consumption totals over the requested window (trace-level) —
- * a flat per-(agent, version, folder) breakdown of AGU and PLTU consumed.
+ * a flat per-(agent, version, folder) breakdown of Agent Units and Platform Units consumed.
  */
 interface AgentTraceGetUnitConsumptionResponse {
     /** Agent ID these totals belong to. */
@@ -17638,33 +19242,33 @@ interface AgentSpanGetResponse {
     status: string;
     /** Organization ID (GUID). */
     organizationId: string;
-    /** Tenant ID (GUID). May be `null`. */
+    /** Tenant ID (GUID). */
     tenantId: string | null;
-    /** Span retention expiry time. May be `null`. */
+    /** Span retention expiry time. */
     expiredTime: string | null;
-    /** Folder key (GUID) the span was recorded in. May be `null`. */
+    /** Folder key (GUID) the span was recorded in. */
     folderKey: string | null;
-    /** Span source. May be `null`. */
+    /** Span source. */
     source: string | null;
-    /** Span type. May be `null`. */
+    /** Span type. */
     spanType: string | null;
-    /** Process key (GUID). May be `null`. */
+    /** Process key (GUID). */
     processKey: string | null;
-    /** Job key (GUID). May be `null`. */
+    /** Job key (GUID). */
     jobKey: string | null;
-    /** Reference ID (GUID). May be `null`. */
+    /** Reference ID (GUID). */
     referenceId: string | null;
-    /** Verbosity level. May be `null`. */
+    /** Verbosity level. */
     verbosityLevel: string | null;
     /** Record last-updated time. */
     updatedAt: string;
     /** Whether the span payload is stored as a large payload. */
     isLargePayload: boolean;
-    /** Payload compression type. May be `null`. */
+    /** Payload compression type. */
     compressionType: string | null;
-    /** Agent version that produced the span. May be `null`. */
+    /** Agent version that produced the span. */
     agentVersion: string | null;
-    /** Raw span context as a JSON string. May be `null`. */
+    /** Raw span context as a JSON string. */
     context: string | null;
 }
 /**
@@ -17686,6 +19290,153 @@ type AgentTraceGetSpansByReferenceOptions = PaginationOptions & {
     /** Execution type filter */
     executionType?: SpanExecutionType;
 };
+/**
+ * Evaluation mode of a governance decision.
+ */
+declare enum AgentGovernanceMode {
+    /** Policy evaluated and logged, but not enforced. */
+    Audit = "AUDIT",
+    /** Policy evaluated and enforced. */
+    Enforce = "ENFORCE",
+    /** Unrecognized or missing mode. */
+    Unknown = "Unknown"
+}
+/**
+ * Verdict of a governance decision (`Deny` = violation).
+ */
+declare enum AgentGovernanceVerdict {
+    /** Allowed — not a violation. */
+    Allow = "ALLOW",
+    /** Denied — counts as a violation. */
+    Deny = "DENY",
+    /** Unrecognized or missing verdict. */
+    Unknown = "Unknown"
+}
+/**
+ * A single governance decision — one policy's allow/deny result for an agent run.
+ */
+interface AgentGovernanceDecisionGetResponse {
+    /** Tenant ID (GUID). */
+    tenantId: string | null;
+    /** Decision window start time — ISO 8601, UTC. */
+    startTime: string;
+    /** Decision window end time — ISO 8601, UTC. */
+    endTime: string | null;
+    /** Trace ID (GUID). */
+    traceId: string | null;
+    /** Job key (GUID). */
+    jobKey: string | null;
+    /** Folder key (GUID). */
+    folderKey: string | null;
+    /** Runtime the evaluator ran in (context, not a filter). */
+    source: string | null;
+    /** Policy ID. */
+    policyId: string | null;
+    /** Policy display name. */
+    policyName: string | null;
+    /** Governance pack name. */
+    packName: string | null;
+    /** Governance hook (e.g. `BEFORE_MODEL`). */
+    hook: string | null;
+    /** Evaluation mode, normalized to {@link AgentGovernanceMode} ({@link AgentGovernanceMode.Unknown} when missing/unrecognized). */
+    mode: AgentGovernanceMode;
+    /** Enforcement action applied. `null` in audit mode (no action enforced). */
+    actionApplied: string | null;
+    /** Verdict, normalized to {@link AgentGovernanceVerdict} (`Deny` = violation). */
+    evaluatorResult: AgentGovernanceVerdict;
+    /** Human-readable reason. */
+    reason: string | null;
+    /** Resolved agent ID (GUID). */
+    agentId: string | null;
+    /** Agent display name. */
+    agentName: string | null;
+}
+/**
+ * Options for the governance decisions query — optional filters plus pagination.
+ */
+type AgentGovernanceDecisionsOptions = PaginationOptions & {
+    /** Inclusive upper bound for the query window. Defaults to now when omitted. */
+    endTime?: Date;
+    /** Filter on the governance hook. */
+    hook?: string;
+    /** Filter on the verdict. */
+    evaluatorResult?: AgentGovernanceVerdict;
+    /** Filter on a single policy ID. */
+    policyId?: string;
+    /** Filter on a single agent by its project key. */
+    agentId?: string;
+    /** When `true`, restrict to violations (deny verdicts). */
+    violationsOnly?: boolean;
+};
+/**
+ * One breakdown entry in the governance summary — counts for a single key.
+ */
+interface AgentGovernanceCountItem {
+    /** The value this row groups by — the distinct hook, agent id, policy id, or pack name for this breakdown. */
+    key: string | null;
+    /** Display name (populated for the policy and agent breakdowns). */
+    name: string | null;
+    /** Number of decisions for this key. */
+    count: number;
+    /** Number of violations (deny verdicts) for this key. */
+    violationCount: number;
+}
+/**
+ * Sections the governance summary can compute. `action` and `mode` are opt-in.
+ */
+declare enum AgentGovernanceSection {
+    /** Scalar totals (`total`, `violations`). */
+    Totals = "totals",
+    /** Breakdown by governance hook. */
+    Hook = "hook",
+    /** Breakdown by agent. */
+    Agent = "agent",
+    /** Breakdown by policy. */
+    Policy = "policy",
+    /** Breakdown by governance pack. */
+    Pack = "pack",
+    /** Breakdown by enforcement action (opt-in). */
+    Action = "action",
+    /** Breakdown by evaluation mode (opt-in). */
+    Mode = "mode"
+}
+/**
+ * Aggregated governance posture over the requested window.
+ */
+interface AgentGovernanceGetSummaryResponse {
+    /** Total decisions in the window. */
+    total: number;
+    /** Total violations (deny verdicts). */
+    violations: number;
+    /** Breakdown by governance hook. */
+    byHook: AgentGovernanceCountItem[];
+    /** Breakdown by agent. */
+    byAgent: AgentGovernanceCountItem[];
+    /** Breakdown by policy. */
+    byPolicy: AgentGovernanceCountItem[];
+    /** Breakdown by governance pack. */
+    byPack: AgentGovernanceCountItem[];
+    /** Breakdown by enforcement action. Empty unless `action` is requested in `sections`. */
+    byAction: AgentGovernanceCountItem[];
+    /** Breakdown by evaluation mode. Empty unless `mode` is requested in `sections`. */
+    byMode: AgentGovernanceCountItem[];
+}
+/**
+ * Options for the governance summary.
+ */
+interface AgentGovernanceSummaryOptions {
+    /** Inclusive upper bound for the query window. Defaults to now when omitted. */
+    endTime?: Date;
+    /** Top-N size for each breakdown. */
+    topN?: number;
+    /** Restrict totals and breakdowns to a single governance pack. */
+    packName?: string;
+    /**
+     * Which sections to compute. Omit for the default set
+     * (`totals`, `hook`, `agent`, `policy`, `pack`); `action` and `mode` are opt-in.
+     */
+    sections?: AgentGovernanceSection[];
+}
 
 /**
  * Service for retrieving UiPath Agent trace metrics.
@@ -17769,7 +19520,7 @@ interface AgentTracesServiceModel {
      * // Get per-agent unit consumption
      * const result = await trace.getUnitConsumption();
      * result.forEach((row) => {
-     *   console.log(`${row.agentId}: ${row.agentUnitsConsumed} AGU, ${row.platformUnitsConsumed} PLTU`);
+     *   console.log(`${row.agentId}: ${row.agentUnitsConsumed} Agent Units, ${row.platformUnitsConsumed} Platform Units`);
      * });
      * ```
      * @example
@@ -17808,10 +19559,6 @@ interface AgentTracesServiceModel {
     /**
      * Retrieves spans whose reference hierarchy contains the given reference id.
      *
-     * Returns a {@link PaginatedResponse} when pagination options (`pageSize`,
-     * `cursor`, or `jumpToPage`) are provided, otherwise a
-     * {@link NonPaginatedResponse}.
-     *
      * @param referenceId - Reference id matched against each span's reference hierarchy
      * @param options - Optional pagination and hierarchy/time filters
      * @returns Promise resolving to a paginated or non-paginated list of {@link AgentSpanGetResponse}
@@ -17844,6 +19591,104 @@ interface AgentTracesServiceModel {
      * ```
      */
     getSpansByReference<T extends AgentTraceGetSpansByReferenceOptions = AgentTraceGetSpansByReferenceOptions>(referenceId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<AgentSpanGetResponse> : NonPaginatedResponse<AgentSpanGetResponse>>;
+    /**
+     * Lists individual governance decisions from agent execution traces — each
+     * policy check's allow/deny outcome with its agent, policy, pack, hook, and
+     * mode, plus the trace it belongs to — over the requested window. Filterable
+     * and paginated.
+     *
+     * @remarks Requires the caller to be an organization admin. Non-admin callers get a `403` and the SDK throws an {@link AuthorizationError}.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param options - Optional window end, filters, and pagination
+     * @returns Promise resolving to a paginated or non-paginated list of {@link AgentGovernanceDecisionGetResponse}
+     * @example
+     * ```typescript
+     * import { AgentTraces } from '@uipath/uipath-typescript/traces';
+     *
+     * const trace = new AgentTraces(sdk);
+     *
+     * // Decision rows since a start time
+     * const result = await trace.getGovernanceDecisions(new Date('2025-05-01T00:00:00Z'));
+     * result.items.forEach((row) => {
+     *   console.log(`${row.hook} ${row.policyId}: ${row.evaluatorResult}`);
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * // Violations only, for one agent, paginated
+     * const page = await trace.getGovernanceDecisions(new Date('2025-05-01T00:00:00Z'), {
+     *   endTime: new Date('2025-06-01T00:00:00Z'),
+     *   violationsOnly: true,
+     *   agentId: '<agentProjectKey>',
+     *   pageSize: 25,
+     * });
+     * if (page.hasNextPage && page.nextCursor) {
+     *   const next = await trace.getGovernanceDecisions(new Date('2025-05-01T00:00:00Z'), { cursor: page.nextCursor });
+     * }
+     * ```
+     * @example
+     * ```typescript
+     * import { isAuthorizationError } from '@uipath/uipath-typescript/core';
+     *
+     * // Non-admin callers get a 403
+     * try {
+     *   await trace.getGovernanceDecisions(new Date('2025-05-01T00:00:00Z'));
+     * } catch (error) {
+     *   if (isAuthorizationError(error)) {
+     *     console.error('Governance data requires an organization admin.');
+     *   }
+     * }
+     * ```
+     */
+    getGovernanceDecisions<T extends AgentGovernanceDecisionsOptions = AgentGovernanceDecisionsOptions>(startTime: Date, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<AgentGovernanceDecisionGetResponse> : NonPaginatedResponse<AgentGovernanceDecisionGetResponse>>;
+    /**
+     * Summarizes governance decisions across agent execution traces — total
+     * decisions and violations, plus top breakdowns by hook, agent, policy, and
+     * pack — over the requested window. Filterable.
+     *
+     * @remarks Requires the caller to be an organization admin. Non-admin callers get a `403` and the SDK throws an {@link AuthorizationError}.
+     *
+     * @param startTime - Inclusive lower bound for the query window
+     * @param options - Optional window end, top-N, pack scope, and sections
+     * @returns Promise resolving to {@link AgentGovernanceGetSummaryResponse}
+     * @example
+     * ```typescript
+     * import { AgentTraces } from '@uipath/uipath-typescript/traces';
+     *
+     * const trace = new AgentTraces(sdk);
+     *
+     * // Default posture since a start time
+     * const summary = await trace.getGovernanceSummary(new Date('2025-05-01T00:00:00Z'));
+     * console.log(`${summary.violations} / ${summary.total} violations`);
+     * summary.byPolicy.forEach((p) => console.log(`${p.key}: ${p.violationCount}`));
+     * ```
+     * @example
+     * ```typescript
+     * import { AgentGovernanceSection } from '@uipath/uipath-typescript/traces';
+     *
+     * // Top 5 per breakdown, scoped to a pack, including the opt-in action/mode sections
+     * const summary = await trace.getGovernanceSummary(new Date('2025-05-01T00:00:00Z'), {
+     *   topN: 5,
+     *   packName: 'ISO/IEC 42001:2023 Runtime',
+     *   sections: [AgentGovernanceSection.Action, AgentGovernanceSection.Mode],
+     * });
+     * ```
+     * @example
+     * ```typescript
+     * import { isAuthorizationError } from '@uipath/uipath-typescript/core';
+     *
+     * // Non-admin callers get a 403
+     * try {
+     *   await trace.getGovernanceSummary(new Date('2025-05-01T00:00:00Z'));
+     * } catch (error) {
+     *   if (isAuthorizationError(error)) {
+     *     console.error('Governance data requires an organization admin.');
+     *   }
+     * }
+     * ```
+     */
+    getGovernanceSummary(startTime: Date, options?: AgentGovernanceSummaryOptions): Promise<AgentGovernanceGetSummaryResponse>;
 }
 
 /**
@@ -18119,5 +19964,5 @@ declare const telemetryClient: {
     setUserId(userId: string): void;
 };
 
-export { AgentErrorSortColumn, AgentListSortColumn, AgentMap, AgentMemoryExecutionType, SpanExecutionType as AgentTraceExecutionType, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CitationErrorType, ConversationGetAllFilterMap, ConversationMap, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, index as DuFramework, EntityAggregateFunction, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, ExchangeMap, FeedbackRating, FeedbackStatus, FieldDisplayType, HttpStatus, InputStreamSpeechSensitivity, InstanceFinalStatus, InstanceStatus, InterruptType, JobPriority, JobSourceType, JobState, JobSubState, JobType, JoinType, LogicalOperator$1 as LogicalOperator, MAX_PAGE_SIZE, MessageMap, MessageRole, NetworkError, NotFoundError, PackageSourceType, PackageType, PolicyEvaluationResult, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, QueryFilterOperator, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, RuntimeType, SLADurationUnit, ServerError, ServerlessJobType, SlaSummaryStatus, SortOrder, SpanAttachmentDirection, SpanAttachmentProvider, SpanExecutionType, SpanPermissionStatus, SpanSource, SpanStatus, SpanVerbosityLevel, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskAssignmentCriteria, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, TaskUserType, TimeInterval, UiPath, UiPathError, UiPathMetaTags, UserSettingsMap, ValidationError, createAgentWithMethods, createCaseInstanceWithMethods, createCaseWithMethods, createConversationWithMethods, createEntityWithMethods, createJobWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getAppBase, getAsset, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, loadFromMetaTags, telemetryClient, track, trackEvent };
-export type { AgentAppearance, AgentConversationServiceModel, AgentCreateConversationOptions, AgentError, AgentErrorOrderBy, AgentFilterOptions, AgentGetAllOptions, AgentGetByIdResponse, AgentGetConsumptionTimelineOptions, AgentGetConsumptionTimelineResponse, AgentGetErrorsOptions, AgentGetErrorsTimelineOptions, AgentGetErrorsTimelineResponse, AgentGetLatencyTimelineOptions, AgentGetLatencyTimelineResponse, AgentGetResponse, AgentInput, AgentJobInfo, AgentListItem, AgentListOrderBy, AgentMemoryFilterOptions, AgentMemoryGetCallsTimelineOptions, AgentMemoryGetCallsTimelineResponse, AgentMemoryGetTimelineOptions, AgentMemoryGetTimelineResponse, AgentMemoryGetTopSpacesOptions, AgentMemoryGetTopSpacesResponse, AgentMemoryServiceModel, AgentMethods, AgentServiceModel, AgentSpanGetResponse, AgentStartingPrompt, AgentTraceFilterOptions, AgentTraceGetErrorsTimelineOptions, AgentTraceGetErrorsTimelineResponse, AgentTraceGetLatencyTimelineOptions, AgentTraceGetLatencyTimelineResponse, AgentTraceGetSpansByReferenceOptions, AgentTraceGetUnitConsumptionOptions, AgentTraceGetUnitConsumptionResponse, AgentTracesServiceModel, ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetByNameOptions, AssetGetResponse, AssetNewValue, AssetServiceModel, AssetUpdateValueByIdOptions, AsyncInputStream, AsyncInputStreamChunkEvent, AsyncInputStreamEndEvent, AsyncInputStreamEvent, AsyncInputStreamStartEvent, AsyncToolCallStream, AttachmentGetByIdOptions, AttachmentResponse, AttachmentServiceModel, BaseConfig, BaseOptions, BaseProcessStartRequest, BlobItem, BodyOptions, BpmnXmlString, BucketDeleteFileOptions, BucketFile, BucketGetAllOptions, BucketGetByIdOptions, BucketGetByNameOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetFilesOptions, BucketGetReadUriOptions, BucketGetReadUriRequestOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadFileRequestOptions, BucketUploadResponse, CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetAllWithMethodsResponse, CaseGetStageResponse, CaseGetTopDurationResponse, CaseGetTopFaultedCountResponse, CaseGetTopRunCountResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstanceSlaSummaryOptions, CaseInstanceStageSLAOptions, CaseInstanceStageSLAResponse, CaseInstanceStageSLAStage, CaseInstancesServiceModel, CaseMethods, CasesServiceModel, ChoiceSetCreateOptions, ChoiceSetDeleteByIdOptions, ChoiceSetGetAllOptions, ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, ChoiceSetUpdateOptions, ChoiceSetValueDeleteOptions, ChoiceSetValueInsertOptions, ChoiceSetValueInsertResponse, ChoiceSetValueUpdateOptions, ChoiceSetValueUpdateResponse, Citation, CitationEndEvent, CitationError, CitationEvent, CitationOptions, CitationSource, CitationSourceBase, CitationSourceMedia, CitationSourceUrl, CitationStartEvent, CollectionResponse, CompletedContentPart, CompletedMessage, CompletedToolCall, ContentPart, ContentPartChunkEvent, ContentPartData, ContentPartEndEvent, ContentPartEvent, ContentPartGetResponse, ContentPartInterrupted, ContentPartStartEvent, ContentPartStartMetaData, ContentPartStream, ConversationAttachmentCreateResponse, ConversationAttachmentUploadResponse, ConversationCreateOptions, ConversationCreateResponse, ConversationDeleteResponse, ConversationEvent, ConversationExchangeServiceModel, ConversationGetAllOptions, ConversationGetResponse, ConversationJobStartOverrides, ConversationMethods, ConversationServiceModel, ConversationSessionMethods, ConversationSessionOptions, ConversationUpdateOptions, ConversationUpdateResponse, ConversationalAgentOptions, ConversationalAgentServiceModel, CreateFeedbackOptions, CustomKeyValuePair, ElementExecutionMetadata, ElementGetTopFailedCountResponse, ElementMetaData, ElementRunMetadata, ElementStats, EntityAggregate, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityCreateFieldOptions, EntityCreateOptions, EntityDeleteAttachmentOptions, EntityDeleteAttachmentResponse, EntityDeleteByIdOptions, EntityDeleteOptions, EntityDeleteRecordByIdOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityDownloadAttachmentOptions, EntityFieldBase, EntityFieldUpdateOptions, EntityFileType, EntityFolderScopedOptions, EntityGetAllOptions, EntityGetAllRecordsOptions, EntityGetByIdOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityImportRecordsByIdOptions, EntityImportRecordsResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityQueryFilter, EntityQueryFilterGroup, EntityQueryRecordsOptions, EntityQueryRecordsResponse, EntityQuerySortOption, EntityRecord, EntityRemoveFieldOptions, EntityServiceModel, EntityUpdateByIdOptions, EntityUpdateOptions, EntityUpdateRecordOptions, EntityUpdateRecordResponse, EntityUpdateRecordsOptions, EntityUpdateResponse, EntityUploadAttachmentOptions, EntityUploadAttachmentResponse, ErrorEndEvent, ErrorEvent, ErrorStartEvent, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, ExceptionReportSubmitResult, Exchange, ExchangeEndEvent, ExchangeEvent, ExchangeGetAllOptions, ExchangeGetByIdOptions, ExchangeGetResponse, ExchangeServiceModel, ExchangeStartEvent, ExchangeStream, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, ExternalValue, FailureRecord, FeatureFlags, FeedbackCategory, FeedbackCategoryInput, FeedbackCategoryResponse, FeedbackCreateCategoryOptions, FeedbackCreateResponse, FeedbackDeleteCategoryOptions, FeedbackGetAllOptions, FeedbackGetCategoriesOptions, FeedbackGetResponse, FeedbackOptions, FeedbackResponse, FeedbackServiceModel, FeedbackSubmitOptions, FeedbackUpdateOptions, Field$1 as Field, FieldDataType, FieldMetaData, FileUploadAccess, FolderProperties, FolderScopedOptions, GenericInterruptStartEvent, GetTopBaseResponse, GetTopDurationResponse, GetTopFaultedCountResponse, GetTopRunCountResponse, GlobalVariableMetaData, GovernanceFilterOptions, GovernanceOperationSummary, GovernancePolicyTrace, GovernancePolicyTraceGetAllOptions, GovernanceServiceModel, HasPaginationOptions, Headers, HttpMethod, InlineOrExternalValue, InlineValue, InstanceStatusTimelineResponse, Interrupt, InterruptEndEvent, InterruptEvent, InterruptStartEvent, JSONArray, JSONObject, JSONPrimitive, JSONValue, JobAttachment, JobError, JobGetAllOptions, JobGetByIdOptions, JobGetResponse, JobMethods, JobResumeOptions, JobServiceModel, JobStopOptions, LabelUpdatedEvent, Machine, MaestroProcessGetAllResponse, MaestroProcessesServiceModel, MakeOptional, MakeRequired, Message, MessageEndEvent, MessageEvent, MessageGetResponse, MessageServiceModel, MessageStartEvent, MessageStream, MetaData, MetaEvent, NonPaginatedResponse, OAuthFields, OperationResponse, OrchestratorDuModuleServiceModel, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, PartialUiPathConfig, ProcessExtractedDataOptions, ProcessExtractedDataRequest, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetByNameOptions, ProcessGetResponse, ProcessGetTopDurationResponse, ProcessGetTopFaultedCountResponse, ProcessGetTopRunCountResponse, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMetadata, ProcessMethods, ProcessProperties, ProcessServiceModel, ProcessStartOptions, ProcessStartRequest, ProcessStartRequestWithKey, ProcessStartRequestWithName, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawAgentGetByIdResponse, RawAgentGetResponse, RawCaseInstanceGetResponse, RawConversationGetResponse, RawEntityGetResponse, RawJobGetResponse, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SessionCapabilities, SessionEndEvent, SessionEndingEvent, SessionStartEvent, SessionStartedEvent, SessionStream, Simplify, SlaSummaryResponse, SourceJoinCriteria, SpanAttachment, SpanContext, SpanGetResponse, SpanReferenceHierarchyEntry, SqlType, StageSLA, StageTask, SubmitExceptionReportOptions, SubmitExceptionReportResponse, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimelineOptions, TimeoutOptions, ToolCall, ToolCallConfirmationEndValue, ToolCallConfirmationEvent, ToolCallConfirmationInterruptStartEvent, ToolCallConfirmationValue, ToolCallEndEvent, ToolCallEvent, ToolCallInputValue, ToolCallOutputValue, ToolCallResult, ToolCallStartEvent, ToolCallStream, TopQueryOptions, TracesGetByIdOptions, TracesServiceModel, UiPathSDKConfig, UserLoginInfo, UserSettingsGetResponse, UserSettingsServiceModel, UserSettingsUpdateOptions, UserSettingsUpdateResponse };
+export { AgentErrorSortColumn, AgentExecutionType, AgentGovernanceMode, AgentGovernanceSection, AgentGovernanceVerdict, AgentListSortColumn, AgentMap, AgentMemoryExecutionType, SpanExecutionType as AgentTraceExecutionType, AgentType, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CitationErrorType, ConversationGetAllFilterMap, ConversationMap, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, index as DuFramework, EntityAggregateFunction, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, ExchangeMap, FeedbackRating, FeedbackStatus, FieldDisplayType, HttpStatus, InputStreamSpeechSensitivity, InstanceFinalStatus, InstanceStatus, InterruptType, JobPriority, JobSourceType, JobState, JobSubState, JobType, JoinType, LogicalOperator$1 as LogicalOperator, MAX_PAGE_SIZE, MessageMap, MessageRole, NetworkError, NotFoundError, PackageSourceType, PackageType, PolicyEvaluationResult, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, QueryFilterOperator, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, RuntimeType, SLADurationUnit, ServerError, ServerlessJobType, SlaSummaryStatus, SortOrder, SpanAttachmentDirection, SpanAttachmentProvider, SpanExecutionType, SpanPermissionStatus, SpanSource, SpanStatus, SpanVerbosityLevel, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskAssignmentCriteria, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, TaskUserType, TimeInterval, UiPath, UiPathError, UiPathMetaTags, UserSettingsMap, ValidationError, createAgentWithMethods, createCaseInstanceWithMethods, createCaseWithMethods, createConversationWithMethods, createEntityWithMethods, createJobWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getAppBase, getAsset, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, loadFromMetaTags, telemetryClient, track, trackEvent };
+export type { AgentAppearance, AgentConsumption, AgentConversationServiceModel, AgentCreateConversationOptions, AgentError, AgentErrorOrderBy, AgentFilterOptions, AgentGetAllOptions, AgentGetByIdResponse, AgentGetConsumptionTimelineOptions, AgentGetConsumptionTimelineResponse, AgentGetErrorsOptions, AgentGetErrorsTimelineOptions, AgentGetErrorsTimelineResponse, AgentGetIncidentDistributionOptions, AgentGetIncidentDistributionResponse, AgentGetLatencyTimelineOptions, AgentGetLatencyTimelineResponse, AgentGetResponse, AgentGetSummaryOptions, AgentGetSummaryResponse, AgentGetTopConsumptionOptions, AgentGetTopConsumptionResponse, AgentGetTopErrorCountOptions, AgentGetTopErrorCountResponse, AgentGetUnitConsumptionSummaryOptions, AgentGetUnitConsumptionSummaryResponse, AgentGovernanceCountItem, AgentGovernanceDecisionGetResponse, AgentGovernanceDecisionsOptions, AgentGovernanceGetSummaryResponse, AgentGovernanceSummaryOptions, AgentInput, AgentJobConsumptionSummary, AgentJobInfo, AgentListItem, AgentListOrderBy, AgentMemoryFilterOptions, AgentMemoryGetCallsTimelineOptions, AgentMemoryGetCallsTimelineResponse, AgentMemoryGetTimelineOptions, AgentMemoryGetTimelineResponse, AgentMemoryGetTopSpacesOptions, AgentMemoryGetTopSpacesResponse, AgentMemoryServiceModel, AgentMethods, AgentServiceModel, AgentSpanGetResponse, AgentStartingPrompt, AgentSummaryEntry, AgentSummaryPeriod, AgentTopErrorCount, AgentTraceFilterOptions, AgentTraceGetErrorsTimelineOptions, AgentTraceGetErrorsTimelineResponse, AgentTraceGetLatencyTimelineOptions, AgentTraceGetLatencyTimelineResponse, AgentTraceGetSpansByReferenceOptions, AgentTraceGetUnitConsumptionOptions, AgentTraceGetUnitConsumptionResponse, AgentTracesServiceModel, AgentUnitConsumptionEntry, AgentUnitConsumptionPeriod, ArgumentMetadata, AssetGetAllOptions, AssetGetByIdOptions, AssetGetByNameOptions, AssetGetResponse, AssetNewValue, AssetServiceModel, AssetUpdateValueByIdOptions, AsyncInputStream, AsyncInputStreamChunkEvent, AsyncInputStreamEndEvent, AsyncInputStreamEvent, AsyncInputStreamStartEvent, AsyncToolCallStream, AttachmentGetByIdOptions, AttachmentResponse, AttachmentServiceModel, BaseConfig, BaseOptions, BaseProcessStartRequest, BlobItem, BodyOptions, BpmnXmlString, BucketDeleteFileOptions, BucketFile, BucketGetAllOptions, BucketGetByIdOptions, BucketGetByNameOptions, BucketGetFileMetaDataOptions, BucketGetFileMetaDataResponse, BucketGetFileMetaDataWithPaginationOptions, BucketGetFilesOptions, BucketGetReadUriOptions, BucketGetReadUriRequestOptions, BucketGetResponse, BucketGetUriOptions, BucketGetUriResponse, BucketServiceModel, BucketUploadFileOptions, BucketUploadFileRequestOptions, BucketUploadResponse, CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetAllWithMethodsResponse, CaseGetStageResponse, CaseGetTopDurationResponse, CaseGetTopFaultedCountResponse, CaseGetTopRunCountResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstanceSlaSummaryOptions, CaseInstanceStageSLAOptions, CaseInstanceStageSLAResponse, CaseInstanceStageSLAStage, CaseInstancesServiceModel, CaseMethods, CasesServiceModel, ChoiceSetCreateOptions, ChoiceSetDeleteByIdOptions, ChoiceSetGetAllOptions, ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, ChoiceSetUpdateOptions, ChoiceSetValueDeleteOptions, ChoiceSetValueInsertOptions, ChoiceSetValueInsertResponse, ChoiceSetValueUpdateOptions, ChoiceSetValueUpdateResponse, Citation, CitationEndEvent, CitationError, CitationEvent, CitationOptions, CitationSource, CitationSourceBase, CitationSourceMedia, CitationSourceUrl, CitationStartEvent, ClientSideTool, CollectionResponse, CompletedContentPart, CompletedMessage, CompletedToolCall, ContentPart, ContentPartChunkEvent, ContentPartData, ContentPartEndEvent, ContentPartEvent, ContentPartGetResponse, ContentPartInterrupted, ContentPartStartEvent, ContentPartStartMetaData, ContentPartStream, ConversationAttachmentCreateResponse, ConversationAttachmentUploadResponse, ConversationCreateOptions, ConversationCreateResponse, ConversationDeleteResponse, ConversationEvent, ConversationExchangeServiceModel, ConversationGetAllOptions, ConversationGetResponse, ConversationJobStartOverrides, ConversationMethods, ConversationServiceModel, ConversationSessionMethods, ConversationSessionOptions, ConversationUpdateOptions, ConversationUpdateResponse, ConversationalAgentOptions, ConversationalAgentServiceModel, CreateFeedbackOptions, CustomKeyValuePair, DurationStats, ElementExecutionMetadata, ElementGetTopFailedCountResponse, ElementMetaData, ElementRunMetadata, ElementStats, EntityAggregate, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityCreateFieldOptions, EntityCreateOptions, EntityDeleteAttachmentOptions, EntityDeleteAttachmentResponse, EntityDeleteByIdOptions, EntityDeleteOptions, EntityDeleteRecordByIdOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityDownloadAttachmentOptions, EntityFieldBase, EntityFieldUpdateOptions, EntityFileType, EntityFolderScopedOptions, EntityGetAllOptions, EntityGetAllRecordsOptions, EntityGetByIdOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityImportRecordsByIdOptions, EntityImportRecordsResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityQueryFilter, EntityQueryFilterGroup, EntityQueryRecordsOptions, EntityQueryRecordsResponse, EntityQuerySortOption, EntityRecord, EntityRemoveFieldOptions, EntityServiceModel, EntityUpdateByIdOptions, EntityUpdateOptions, EntityUpdateRecordOptions, EntityUpdateRecordResponse, EntityUpdateRecordsOptions, EntityUpdateResponse, EntityUploadAttachmentOptions, EntityUploadAttachmentResponse, ErrorEndEvent, ErrorEvent, ErrorStartEvent, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, ExceptionReportSubmitResult, Exchange, ExchangeEndEvent, ExchangeEvent, ExchangeGetAllOptions, ExchangeGetByIdOptions, ExchangeGetResponse, ExchangeServiceModel, ExchangeStartEvent, ExchangeStream, ExecutingToolCallEvent, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, ExternalValue, FailureRecord, FeatureFlags, FeedbackCategory, FeedbackCategoryInput, FeedbackCategoryResponse, FeedbackCreateCategoryOptions, FeedbackCreateResponse, FeedbackDeleteCategoryOptions, FeedbackGetAllOptions, FeedbackGetCategoriesOptions, FeedbackGetResponse, FeedbackOptions, FeedbackResponse, FeedbackServiceModel, FeedbackSubmitOptions, FeedbackUpdateOptions, Field$1 as Field, FieldDataType, FieldMetaData, FileUploadAccess, FolderProperties, FolderScopedOptions, GenericInterruptStartEvent, GetTopBaseResponse, GetTopDurationResponse, GetTopFaultedCountResponse, GetTopRunCountResponse, GlobalVariableMetaData, GovernanceFilterOptions, GovernanceOperationSummary, GovernancePolicyTrace, GovernancePolicyTraceGetAllOptions, GovernanceServiceModel, HasPaginationOptions, Headers, HttpMethod, IncidentTimelineResponse, InlineOrExternalValue, InlineValue, InstanceStats, InstanceStatusTimelineResponse, Interrupt, InterruptEndEvent, InterruptEvent, InterruptStartEvent, JSONArray, JSONObject, JSONPrimitive, JSONValue, JobAttachment, JobError, JobGetAllOptions, JobGetByIdOptions, JobGetResponse, JobMethods, JobResumeOptions, JobServiceModel, JobStopOptions, LabelUpdatedEvent, Machine, MaestroProcessGetAllResponse, MaestroProcessStatsRequest, MaestroProcessesServiceModel, MakeOptional, MakeRequired, Message, MessageEndEvent, MessageEvent, MessageGetResponse, MessageServiceModel, MessageStartEvent, MessageStream, MetaData, MetaEvent, NonPaginatedResponse, OAuthFields, OperationResponse, OrchestratorDuModuleServiceModel, PaginatedResponse, PaginationCursor, PaginationMetadata, PaginationMethodUnion, PaginationOptions, PartialUiPathConfig, ProcessExtractedDataOptions, ProcessExtractedDataRequest, ProcessGetAllOptions, ProcessGetByIdOptions, ProcessGetByNameOptions, ProcessGetResponse, ProcessGetTopDurationResponse, ProcessGetTopFaultedCountResponse, ProcessGetTopRunCountResponse, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessIncidentsServiceModel, ProcessInstanceExecutionHistoryResponse, ProcessInstanceGetAllOptions, ProcessInstanceGetAllWithPaginationOptions, ProcessInstanceGetResponse, ProcessInstanceGetVariablesOptions, ProcessInstanceGetVariablesResponse, ProcessInstanceMethods, ProcessInstanceOperationOptions, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessInstancesServiceModel, ProcessMetadata, ProcessMethods, ProcessProperties, ProcessServiceModel, ProcessStartOptions, ProcessStartRequest, ProcessStartRequestWithKey, ProcessStartRequestWithName, ProcessStartResponse, QueryParams, QueueGetAllOptions, QueueGetByIdOptions, QueueGetResponse, QueueServiceModel, RawAgentGetByIdResponse, RawAgentGetResponse, RawCaseInstanceGetResponse, RawConversationGetResponse, RawEntityGetResponse, RawJobGetResponse, RawMaestroProcessGetAllResponse, RawProcessInstanceGetResponse, RawTaskCreateResponse, RawTaskGetResponse, RequestOptions, RequestSpec, ResponseDictionary, ResponseType, RetryOptions, RobotMetadata, SessionCapabilities, SessionEndEvent, SessionEndingEvent, SessionStartEvent, SessionStartedEvent, SessionStream, Simplify, SlaSummaryResponse, SourceJoinCriteria, SpanAttachment, SpanContext, SpanGetResponse, SpanReferenceHierarchyEntry, SqlType, StageSLA, StageTask, SubmitExceptionReportOptions, SubmitExceptionReportResponse, Tag, TaskActivity, TaskAssignOptions, TaskAssignment, TaskAssignmentOptions, TaskAssignmentResponse, TaskBaseResponse, TaskCompleteOptions, TaskCompletionOptions, TaskCreateOptions, TaskCreateResponse, TaskGetAllOptions, TaskGetByIdOptions, TaskGetResponse, TaskGetUsersOptions, TaskMethods, TaskServiceModel, TaskSlaDetail, TaskSource, TasksUnassignOptions, TimelineOptions, TimeoutOptions, ToolCall, ToolCallConfirmationEndValue, ToolCallConfirmationEvent, ToolCallConfirmationInterruptStartEvent, ToolCallConfirmationValue, ToolCallEndEvent, ToolCallEvent, ToolCallInputValue, ToolCallOutputValue, ToolCallResult, ToolCallStartEvent, ToolCallStream, TopQueryOptions, TracesGetByIdOptions, TracesServiceModel, UiPathSDKConfig, UserLoginInfo, UserSettingsGetResponse, UserSettingsServiceModel, UserSettingsUpdateOptions, UserSettingsUpdateResponse };