@uipath/uipath-typescript 1.3.7 → 1.3.9

package/dist/cases/index.d.ts

@@ -1,5 +1,101 @@
 import { IUiPath } from '../core/index';
 
+/**
+ * Insights Types
+ * Shared types for Maestro insights analytics endpoints
+ */
+/**
+ * Optional filters for Insights "top" endpoint queries.
+ * All fields are optional — pass any combination to narrow results.
+ */
+interface TopQueryOptions {
+    /** Filter by package identifier */
+    packageId?: string;
+    /** Filter by process key */
+    processKey?: string;
+    /** Filter by package version */
+    version?: string;
+}
+/**
+ * Common fields returned by all Insights "top" endpoints
+ */
+interface GetTopBaseResponse {
+    /** The package identifier */
+    packageId: string;
+    /** The unique process key */
+    processKey: string;
+}
+/**
+ * Response for the top run count Insights endpoint
+ */
+interface GetTopRunCountResponse extends GetTopBaseResponse {
+    /** Number of times the process was run in the given time range */
+    runCount: number;
+}
+/**
+ * Response for the top failure count Insights endpoint
+ */
+interface GetTopFaultedCountResponse extends GetTopBaseResponse {
+    /** Number of faulted instances in the given time range */
+    faultedCount: number;
+}
+/**
+ * Time bucketing granularity for insights time-series queries.
+ *
+ * Controls how data points are grouped on the time axis.
+ */
+declare enum TimeInterval {
+    /** Group data points by hour */
+    Hour = "HOUR",
+    /** Group data points by day */
+    Day = "DAY",
+    /** Group data points by week */
+    Week = "WEEK"
+}
+/**
+ * Options for insights time-series queries.
+ */
+interface TimelineOptions {
+    /**
+     * How to group data points on the time axis.
+     * @default TimeInterval.Day
+     */
+    groupBy?: TimeInterval;
+}
+/**
+ * Final instance statuses returned by the instance status timeline endpoint.
+ *
+ * Only includes statuses where the instance has finished execution — Completed, Faulted, or Cancelled.
+ * Active statuses like Running or Paused are not included.
+ */
+declare enum InstanceFinalStatus {
+    /** Instance completed successfully */
+    Completed = "Completed",
+    /** Instance encountered an error */
+    Faulted = "Faulted",
+    /** Instance was cancelled */
+    Cancelled = "Cancelled"
+}
+/**
+ * Instance count for a process with a given status
+ * within a specific time bucket.
+ */
+interface InstanceStatusTimelineResponse {
+    /** Start of the time bucket in local timezone (e.g. `"5/8/2026 12:00:00 AM"`) */
+    startTime: string;
+    /** Instance status */
+    status: InstanceFinalStatus;
+    /** Number of instances with this status in the time bucket */
+    count: number;
+}
+/**
+ * Response for the top duration Insights endpoint
+ */
+interface GetTopDurationResponse extends GetTopBaseResponse {
+    /** Total execution duration in milliseconds */
+    duration: number;
+}
+
 /**
  * Simplified universal pagination cursor
  * Used to fetch next/previous pages
@@ -98,6 +194,7 @@ interface RequestOptions extends BaseOptions {
  * Maestro Cases Types
  * Types and interfaces for Maestro case management
  */
+
 /**
  * Case information with instance statistics
  */
@@ -137,6 +234,27 @@ interface CaseGetAllResponse {
     /** Case instance count - canceling */
     cancelingCount: number;
 }
+/**
+ * Response for a single entry in top cases by run count
+ */
+interface CaseGetTopRunCountResponse extends GetTopRunCountResponse {
+    /** Human-readable case name */
+    name: string;
+}
+/**
+ * Response for a single entry in top cases by failure count
+ */
+interface CaseGetTopFaultedCountResponse extends GetTopFaultedCountResponse {
+    /** Human-readable case name */
+    name: string;
+}
+/**
+ * Response for a single entry in top cases by duration
+ */
+interface CaseGetTopDurationResponse extends GetTopDurationResponse {
+    /** Human-readable case name */
+    name: string;
+}
 
 /**
  * Maestro Cases Models
@@ -177,6 +295,161 @@ interface CasesServiceModel {
      * ```
      */
     getAll(): Promise<CaseGetAllResponse[]>;
+    /**
+     * Get the top 5 case processes ranked by run count within a time range.
+     *
+     * Returns an array of up to 5 case processes sorted by how many times they were executed,
+     * useful for identifying the most active case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopRunCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by run count for the last 7 days
+     * const topProcesses = await cases.getTopRunCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topProcesses) {
+     *   console.log(`${process.packageId}: ${process.runCount} runs`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by run count for a specific package
+     * const filtered = await cases.getTopRunCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopRunCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopRunCountResponse[]>;
+    /**
+     * Get the top 10 case processes ranked by failure count within a time range.
+     *
+     * Returns an array of up to 10 case processes sorted by how many instances faulted,
+     * useful for identifying the most error-prone case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopFaultedCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by faulted count for the last 7 days
+     * const topFailing = await cases.getTopFaultedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topFailing) {
+     *   console.log(`${process.packageId}: ${process.faultedCount} failures`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by faulted count for a specific package
+     * const filtered = await cases.getTopFaultedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopFaultedCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopFaultedCountResponse[]>;
+    /**
+     * Get all instances status counts aggregated by date for case management processes.
+     *
+     * Returns time-grouped counts of case instances grouped by status (Completed, Faulted, Cancelled),
+     * useful for rendering 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 time bucketing granularity
+     * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily instance status for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const statuses = await cases.getInstanceStatusTimeline(sevenDaysAgo, now);
+     *
+     * for (const entry of statuses) {
+     *   console.log(`${entry.startTime} — ${entry.status}: ${entry.count}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/cases';
+     *
+     * // Get weekly breakdown
+     * const statuses = await cases.getInstanceStatusTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @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 the top 5 case processes ranked by total duration within a time range.
+     *
+     * Returns an array of up to 5 case processes sorted by their total execution time,
+     * useful for identifying the longest-running case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopDurationResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by duration for the last 7 days
+     * const topProcesses = await cases.getTopExecutionDuration(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topProcesses) {
+     *   console.log(`${process.packageId}: ${process.duration}ms total`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by duration for a specific package
+     * const filtered = await cases.getTopExecutionDuration(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopExecutionDuration(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopDurationResponse[]>;
 }
 
 /**
@@ -266,6 +539,113 @@ interface CaseAppConfig {
     caseSummary?: string;
     overview?: CaseAppOverview[];
 }
+/**
+ * SLA status for a case instance
+ */
+declare enum SlaSummaryStatus {
+    /** Case is within SLA deadline */
+    ON_TRACK = "On Track",
+    /** Case is approaching SLA deadline based on at-risk percentage threshold */
+    AT_RISK = "At Risk",
+    /** Case has exceeded SLA deadline */
+    OVERDUE = "Overdue",
+    /** Case instance has completed */
+    COMPLETED = "Completed",
+    /** SLA status cannot be determined (no SLA deadline defined) */
+    UNKNOWN = "Unknown"
+}
+/**
+ * Instance status values for case instances and process instances
+ */
+declare enum InstanceStatus {
+    /** Instance status not yet populated by the backend */
+    UNKNOWN = "",
+    CANCELLED = "Cancelled",
+    CANCELING = "Canceling",
+    COMPLETED = "Completed",
+    FAULTED = "Faulted",
+    PAUSED = "Paused",
+    PAUSING = "Pausing",
+    PENDING = "Pending",
+    RESUMING = "Resuming",
+    RETRYING = "Retrying",
+    RUNNING = "Running",
+    UPGRADING = "Upgrading"
+}
+/**
+ * SLA summary response for a single case instance
+ */
+interface SlaSummaryResponse {
+    /** Unique identifier of the case instance */
+    caseInstanceId: string;
+    /** Folder key that the case instance belongs to */
+    folderKey: string;
+    /** Display name of the SLA rule */
+    name: string;
+    /** Human-readable reference number for a case instance */
+    externalId: string;
+    /** Summary text for the case instance — may be empty */
+    caseSummary: string;
+    /** Unique key of the process associated with the case instance */
+    processKey: string;
+    /** SLA deadline timestamp in UTC (ISO 8601 format) */
+    slaDueTime: string;
+    /** Current SLA status indicating whether the deadline is met, at risk, or breached */
+    slaStatus: SlaSummaryStatus;
+    /** Index of the escalation rule currently applied to the SLA */
+    escalationRuleIndex: string;
+    escalationRuleType: EscalationTriggerType;
+    /** Current status of the case instance */
+    instanceStatus: InstanceStatus;
+    /** Last modification timestamp in UTC (ISO 8601 format) */
+    lastModifiedTime: string;
+}
+/**
+ * Options for querying SLA summary
+ */
+type CaseInstanceSlaSummaryOptions = PaginationOptions & {
+    /** Filter to a specific case instance */
+    caseInstanceId?: string;
+    /** Filter by event start time in UTC */
+    startTimeUtc?: Date;
+    /** Filter by event end time in UTC */
+    endTimeUtc?: Date;
+};
+/**
+ * Stage SLA summary for a single stage within a case instance (from Insights RTM)
+ */
+interface CaseInstanceStageSLAStage {
+    /** Stage element identifier */
+    elementId: string;
+    /** Stage display name */
+    name: string;
+    /** Current execution status of the stage */
+    latestStatus: string;
+    /** SLA deadline timestamp in UTC (e.g. `"9/17/2025 8:35:38 PM"`) or empty string if no SLA is configured */
+    slaDueTime: string;
+    /** SLA status for this stage */
+    slaStatus: SlaSummaryStatus;
+    /** Index of the current escalation rule */
+    escalationRuleIndex: string;
+    /** Type of the current escalation rule */
+    escalationRuleType: EscalationTriggerType;
+}
+/**
+ * Stages SLA summary for a single case instance (from Insights RTM)
+ */
+interface CaseInstanceStageSLAResponse {
+    /** Case instance identifier */
+    caseInstanceId: string;
+    /** Stages within this case instance */
+    stages: CaseInstanceStageSLAStage[];
+}
+/**
+ * Options for querying stages SLA summary
+ */
+interface CaseInstanceStageSLAOptions {
+    /** Filter to a specific case instance */
+    caseInstanceId?: string;
+}
 /**
  * Case stage task type
  */
@@ -324,7 +704,9 @@ interface EscalationAction {
  */
 declare enum EscalationTriggerType {
     SLA_BREACHED = "sla-breached",
-    AT_RISK = "at-risk"
+    AT_RISK = "at-risk",
+    /** Default value when no escalation rule is defined */
+    NONE = "None"
 }
 /**
  * Escalation rule trigger metadata
@@ -709,6 +1091,11 @@ type TaskGetResponse = RawTaskGetResponse & TaskMethods;
  * const caseInstances = new CaseInstances(sdk);
  * const allInstances = await caseInstances.getAll();
  * ```
+ *
+ * !!! note
+ *     Methods that rely on the Insights Real-Time Monitoring service (`getSlaSummary`, `getStagesSlaSummary`)
+ *     may have up to ~1 minute latency before reflecting the latest updates. See
+ *     [Real-Time Monitoring Overview](https://docs.uipath.com/insights/automation-cloud/latest/user-guide/real-time-monitoring-overview) for details.
  */
 interface CaseInstancesServiceModel {
     /**
@@ -940,6 +1327,71 @@ interface CaseInstancesServiceModel {
      * ```
      */
     getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(caseInstanceId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Get SLA summary for all case instances across folders.
+     *
+     * Returns SLA status, due times, escalation info, and instance metadata for each case instance.
+     * The default page size is 50, so only the top 50 items are returned when no pagination options are provided.
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to {@link SlaSummaryResponse}, paginated or non-paginated based on options
+     * @example
+     * ```typescript
+     * // Non-paginated (returns top 50 items by default)
+     * const summary = await caseInstances.getSlaSummary();
+     * console.log(`Found ${summary.totalCount} cases`);
+     *
+     * // Filter by case instance ID
+     * const filtered = await caseInstances.getSlaSummary({
+     *   caseInstanceId: '<caseInstanceId>'
+     * });
+     *
+     * // Filter by time range
+     * const timeFiltered = await caseInstances.getSlaSummary({
+     *   startTimeUtc: new Date('2026-01-01'),
+     *   endTimeUtc: new Date('2026-01-31')
+     * });
+     *
+     * // With pagination
+     * const page1 = await caseInstances.getSlaSummary({ pageSize: 25 });
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.getSlaSummary({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page3 = await caseInstances.getSlaSummary({ jumpToPage: 3, pageSize: 25 });
+     * ```
+     */
+    getSlaSummary<T extends CaseInstanceSlaSummaryOptions = CaseInstanceSlaSummaryOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<SlaSummaryResponse> : NonPaginatedResponse<SlaSummaryResponse>>;
+    /**
+     * Get stages SLA summary for case instances across folders.
+     *
+     * Returns stage-level SLA status and escalation information for each case instance, aggregated from Insights Real-Time Monitoring.
+     *
+     * @param options - Optional filtering options
+     * @returns Promise resolving to an array of {@link CaseInstanceStageSLAResponse}
+     * @example
+     * ```typescript
+     * // Get stages SLA summary for all case instances
+     * const stagesSla = await caseInstances.getStagesSlaSummary();
+     * for (const item of stagesSla) {
+     *   console.log(`Instance: ${item.caseInstanceId}`);
+     *   for (const stage of item.stages) {
+     *     console.log(`  Stage: ${stage.name} - SLA Status: ${stage.slaStatus}, Due: ${stage.slaDueTime}`);
+     *   }
+     * }
+     *
+     * // Filter by case instance ID
+     * const filtered = await caseInstances.getStagesSlaSummary({
+     *   caseInstanceId: '<caseInstanceId>'
+     * });
+     *
+     * // Using bound method on a case instance
+     * const instance = await caseInstances.getById('<instanceId>', '<folderKey>');
+     * const stagesSla = await instance.getStagesSlaSummary();
+     * ```
+     */
+    getStagesSlaSummary(options?: CaseInstanceStageSLAOptions): Promise<CaseInstanceStageSLAResponse[]>;
 }
 interface CaseInstanceMethods {
     /**
@@ -989,6 +1441,20 @@ interface CaseInstanceMethods {
      * @returns Promise resolving to human in the loop tasks associated with the case instance
      */
     getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Gets the SLA summary for this case instance.
+     * The default page size is 50, so only the top 50 items are returned when no pagination options are provided.
+     *
+     * @param options - Optional time range filtering and pagination options
+     * @returns Promise resolving to SLA summary items for this case instance
+     */
+    getSlaSummary<T extends Omit<CaseInstanceSlaSummaryOptions, 'caseInstanceId'> = Omit<CaseInstanceSlaSummaryOptions, 'caseInstanceId'>>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<SlaSummaryResponse> : NonPaginatedResponse<SlaSummaryResponse>>;
+    /**
+     * Gets the stages SLA summary for this case instance.
+     *
+     * @returns Promise resolving to an array of stage SLA summary items for this case instance
+     */
+    getStagesSlaSummary(): Promise<CaseInstanceStageSLAResponse[]>;
 }
 type CaseInstanceGetResponse = RawCaseInstanceGetResponse & CaseInstanceMethods;
 /**
@@ -1038,6 +1504,7 @@ interface RequestWithPaginationOptions extends RequestSpec {
             offsetParam?: string;
             tokenParam?: string;
             countParam?: string;
+            convertToSkip?: boolean;
         };
     };
 }
@@ -1254,6 +1721,161 @@ declare class CasesService extends BaseService implements CasesServiceModel {
      * ```
      */
     getAll(): Promise<CaseGetAllResponse[]>;
+    /**
+     * Get the top 5 case processes ranked by run count within a time range.
+     *
+     * Returns an array of up to 5 case processes sorted by how many times they were executed,
+     * useful for identifying the most active case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopRunCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by run count for the last 7 days
+     * const topProcesses = await cases.getTopRunCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topProcesses) {
+     *   console.log(`${process.packageId}: ${process.runCount} runs`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by run count for a specific package
+     * const filtered = await cases.getTopRunCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopRunCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopRunCountResponse[]>;
+    /**
+     * Get all instances status counts aggregated by date for case management processes.
+     *
+     * Returns time-grouped counts of case instances grouped by status (Completed, Faulted, Cancelled),
+     * useful for rendering 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 time bucketing granularity
+     * @returns Promise resolving to an array of {@link InstanceStatusTimelineResponse}
+     *
+     * @example
+     * ```typescript
+     * // Get daily instance status for the last 7 days
+     * const now = new Date();
+     * const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
+     * const statuses = await cases.getInstanceStatusTimeline(sevenDaysAgo, now);
+     *
+     * for (const entry of statuses) {
+     *   console.log(`${entry.startTime} — ${entry.status}: ${entry.count}`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * import { TimeInterval } from '@uipath/uipath-typescript/cases';
+     *
+     * // Get weekly breakdown
+     * const statuses = await cases.getInstanceStatusTimeline(startTime, endTime, {
+     *   groupBy: TimeInterval.Week,
+     * });
+     * ```
+     *
+     * @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 the top 10 case processes ranked by failure count within a time range.
+     *
+     * Returns an array of up to 10 case processes sorted by how many instances faulted,
+     * useful for identifying the most error-prone case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopFaultedCountResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by faulted count for the last 7 days
+     * const topFailing = await cases.getTopFaultedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topFailing) {
+     *   console.log(`${process.packageId}: ${process.faultedCount} failures`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by faulted count for a specific package
+     * const filtered = await cases.getTopFaultedCount(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopFaultedCount(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopFaultedCountResponse[]>;
+    /**
+     * Get the top 5 case processes ranked by total duration within a time range.
+     *
+     * Returns an array of up to 5 case processes sorted by their total execution time,
+     * useful for identifying the longest-running case processes in a given period.
+     *
+     * @param startTime - Start of the time range to query
+     * @param endTime - End of the time range to query
+     * @param options - Optional filters (packageId, processKey, version)
+     * @returns Promise resolving to an array of {@link CaseGetTopDurationResponse}
+     * @example
+     * ```typescript
+     * import { Cases } from '@uipath/uipath-typescript/cases';
+     *
+     * const cases = new Cases(sdk);
+     *
+     * // Get top case processes by duration for the last 7 days
+     * const topProcesses = await cases.getTopExecutionDuration(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date()
+     * );
+     *
+     * for (const process of topProcesses) {
+     *   console.log(`${process.packageId}: ${process.duration}ms total`);
+     * }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Get top case processes by duration for a specific package
+     * const filtered = await cases.getTopExecutionDuration(
+     *   new Date(Date.now() - 7 * 24 * 60 * 60 * 1000),
+     *   new Date(),
+     *   { packageId: '<packageId>' }
+     * );
+     * ```
+     */
+    getTopExecutionDuration(startTime: Date, endTime: Date, options?: TopQueryOptions): Promise<CaseGetTopDurationResponse[]>;
     /**
      * Extract a readable case name from the packageId
      * @param packageId - The full package identifier
@@ -1444,7 +2066,72 @@ declare class CaseInstancesService extends BaseService implements CaseInstancesS
      * @returns Promise resolving to human in the loop tasks associated with the case instance
      */
     getActionTasks<T extends TaskGetAllOptions = TaskGetAllOptions>(caseInstanceId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<TaskGetResponse> : NonPaginatedResponse<TaskGetResponse>>;
+    /**
+     * Get SLA summary for all case instances across folders.
+     *
+     * Returns SLA status, due times, escalation info, and instance metadata for each case instance.
+     * The default page size is 50, so only the top 50 items are returned when no pagination options are provided.
+     *
+     * @param options - Optional filtering and pagination options
+     * @returns Promise resolving to {@link SlaSummaryResponse}, paginated or non-paginated based on options
+     * @example
+     * ```typescript
+     * // Non-paginated (returns top 50 items by default)
+     * const summary = await caseInstances.getSlaSummary();
+     * console.log(`Found ${summary.totalCount} cases`);
+     *
+     * // Filter by case instance ID
+     * const filtered = await caseInstances.getSlaSummary({
+     *   caseInstanceId: '<caseInstanceId>'
+     * });
+     *
+     * // Filter by time range
+     * const timeFiltered = await caseInstances.getSlaSummary({
+     *   startTimeUtc: new Date('2026-01-01'),
+     *   endTimeUtc: new Date('2026-01-31')
+     * });
+     *
+     * // With pagination
+     * const page1 = await caseInstances.getSlaSummary({ pageSize: 25 });
+     * if (page1.hasNextPage) {
+     *   const page2 = await caseInstances.getSlaSummary({ cursor: page1.nextCursor });
+     * }
+     *
+     * // Jump to specific page
+     * const page3 = await caseInstances.getSlaSummary({ jumpToPage: 3, pageSize: 25 });
+     * ```
+     */
+    getSlaSummary<T extends CaseInstanceSlaSummaryOptions = CaseInstanceSlaSummaryOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<SlaSummaryResponse> : NonPaginatedResponse<SlaSummaryResponse>>;
+    /**
+     * Get stages SLA summary for case instances across folders.
+     *
+     * Returns stage-level SLA status and escalation information for each case instance, aggregated from Insights Real-Time Monitoring.
+     *
+     * @param options - Optional filtering options
+     * @returns Promise resolving to an array of {@link CaseInstanceStageSLAResponse}
+     * @example
+     * ```typescript
+     * // Get stages SLA summary for all case instances
+     * const stagesSla = await caseInstances.getStagesSlaSummary();
+     * for (const item of stagesSla) {
+     *   console.log(`Instance: ${item.caseInstanceId}`);
+     *   for (const stage of item.stages) {
+     *     console.log(`  Stage: ${stage.name} - SLA Status: ${stage.slaStatus}, Due: ${stage.slaDueTime}`);
+     *   }
+     * }
+     *
+     * // Filter by case instance ID
+     * const filtered = await caseInstances.getStagesSlaSummary({
+     *   caseInstanceId: '<caseInstanceId>'
+     * });
+     *
+     * // Using bound method on a case instance
+     * const instance = await caseInstances.getById('<instanceId>', '<folderKey>');
+     * const stagesSla = await instance.getStagesSlaSummary();
+     * ```
+     */
+    getStagesSlaSummary(options?: CaseInstanceStageSLAOptions): Promise<CaseInstanceStageSLAResponse[]>;
 }
 
-export { CaseInstancesService as CaseInstances, CaseInstancesService, CasesService as Cases, CasesService, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, SLADurationUnit, StageTaskType, createCaseInstanceWithMethods };
-export type { CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstancesServiceModel, CasesServiceModel, ElementExecutionMetadata, ElementRunMetadata, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, RawCaseInstanceGetResponse, StageSLA, StageTask };
+export { CaseInstancesService as CaseInstances, CaseInstancesService, CasesService as Cases, CasesService, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, InstanceFinalStatus, InstanceStatus, SLADurationUnit, SlaSummaryStatus, StageTaskType, TimeInterval, createCaseInstanceWithMethods };
+export type { CaseAppConfig, CaseAppOverview, CaseGetAllResponse, CaseGetStageResponse, CaseGetTopDurationResponse, CaseGetTopFaultedCountResponse, CaseGetTopRunCountResponse, CaseInstanceExecutionHistoryResponse, CaseInstanceGetAllOptions, CaseInstanceGetAllWithPaginationOptions, CaseInstanceGetResponse, CaseInstanceMethods, CaseInstanceOperationOptions, CaseInstanceOperationResponse, CaseInstanceReopenOptions, CaseInstanceRun, CaseInstanceSlaSummaryOptions, CaseInstanceStageSLAOptions, CaseInstanceStageSLAResponse, CaseInstanceStageSLAStage, CaseInstancesServiceModel, CasesServiceModel, ElementExecutionMetadata, ElementRunMetadata, EscalationAction, EscalationRecipient, EscalationRule, EscalationTriggerMetadata, GetTopBaseResponse, GetTopDurationResponse, GetTopFaultedCountResponse, GetTopRunCountResponse, InstanceStatusTimelineResponse, RawCaseInstanceGetResponse, SlaSummaryResponse, StageSLA, StageTask, TimelineOptions, TopQueryOptions };