@uipath/uipath-typescript 1.3.6 → 1.3.8

package/dist/index.cjs

@@ -4480,6 +4480,7 @@ const ORCHESTRATOR_BASE = 'orchestrator_';
 const PIMS_BASE = 'pims_';
 const DATAFABRIC_BASE = 'datafabric_';
 const IDENTITY_BASE = 'identity_';
+const INSIGHTS_RTM_BASE = 'insightsrtm_';
 
 /**
  * Orchestrator Service Endpoints
@@ -4586,6 +4587,10 @@ const MAESTRO_ENDPOINTS = {
         GET_ELEMENT_EXECUTIONS: (instanceId) => `${PIMS_BASE}/api/v1/element-executions/case-instances/${instanceId}`,
         REOPEN: (instanceId) => `${PIMS_BASE}/api/v1/cases/${instanceId}/reopen`,
     },
+    INSIGHTS: {
+        /** SLA summary for case instances */
+        SLA_SUMMARY: `${INSIGHTS_RTM_BASE}/caseManagement/slaSummary`,
+    },
 };
 
 /**
@@ -5464,7 +5469,7 @@ function normalizeBaseUrl(url) {
 // Connection string placeholder that will be replaced during build
 const CONNECTION_STRING = "InstrumentationKey=a6efa11d-1feb-4508-9738-e13e12dcae5e;IngestionEndpoint=https://westeurope-5.in.applicationinsights.azure.com/;LiveEndpoint=https://westeurope.livediagnostics.monitor.azure.com/;ApplicationId=7c58eb1c-9581-4ba6-839e-11725848a037";
 // SDK Version placeholder 
-const SDK_VERSION = "1.3.6";
+const SDK_VERSION = "1.3.8";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -5811,6 +5816,8 @@ exports.UiPathMetaTags = void 0;
     // Asset resolution and routing
     UiPathMetaTags["CDN_BASE"] = "uipath:cdn-base";
     UiPathMetaTags["APP_BASE"] = "uipath:app-base";
+    // Folder context (injected during coded-app deployment)
+    UiPathMetaTags["FOLDER_KEY"] = "uipath:folder-key";
 })(exports.UiPathMetaTags || (exports.UiPathMetaTags = {}));
 
 /**
@@ -5839,12 +5846,13 @@ function loadFromMetaTags() {
         tenantName: getMetaTagContent(exports.UiPathMetaTags.TENANT_NAME),
         baseUrl: getMetaTagContent(exports.UiPathMetaTags.BASE_URL),
         redirectUri: getMetaTagContent(exports.UiPathMetaTags.REDIRECT_URI),
+        folderKey: getMetaTagContent(exports.UiPathMetaTags.FOLDER_KEY),
     };
     const hasAnyValue = Object.values(config).some(Boolean);
     return hasAnyValue ? config : null;
 }
 
-var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_multiLogin, _UiPath_initializeWithConfig, _UiPath_loadConfig;
+var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_multiLogin, _UiPath_metaFolderKey, _UiPath_initializeWithConfig, _UiPath_loadConfig;
 /**
  * UiPath - Core SDK class for authentication and configuration management.
  *
@@ -5885,8 +5893,13 @@ let UiPath$1 = class UiPath {
         _UiPath_initialized.set(this, false);
         _UiPath_partialConfig.set(this, void 0);
         _UiPath_multiLogin.set(this, false);
+        // Folder key sourced only from `<meta name="uipath:folder-key">` (coded-app
+        // deployments). Not accepted via the public constructor; lives here so the
+        // SDK can flow it through to BaseService.config without polluting BaseConfig.
+        _UiPath_metaFolderKey.set(this, void 0);
         // Load configuration from meta tags
         const configFromMetaTags = loadFromMetaTags();
+        __classPrivateFieldSet(this, _UiPath_metaFolderKey, configFromMetaTags?.folderKey, "f");
         // Merge configuration: constructor config overrides meta tags
         const mergedConfig = config ? { ...configFromMetaTags, ...config } : configFromMetaTags;
         if (mergedConfig && isCompleteConfig(mergedConfig)) {
@@ -6015,7 +6028,7 @@ let UiPath$1 = class UiPath {
         __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
     }
 };
-_UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_multiLogin = new WeakMap(), _UiPath_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
+_UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_multiLogin = new WeakMap(), _UiPath_metaFolderKey = new WeakMap(), _UiPath_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
     // Validate and normalize the configuration
     validateConfig(config);
     const hasSecretAuth = hasSecretConfig(config);
@@ -6028,7 +6041,7 @@ _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_ini
         secret: hasSecretAuth ? config.secret : undefined,
         clientId: hasOAuthAuth ? config.clientId : undefined,
         redirectUri: hasOAuthAuth ? config.redirectUri : undefined,
-        scope: hasOAuthAuth ? config.scope : undefined
+        scope: hasOAuthAuth ? config.scope : undefined,
     });
     const executionContext = new ExecutionContext();
     __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
@@ -6036,11 +6049,14 @@ _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_ini
         __classPrivateFieldGet(this, _UiPath_authService, "f").setMultiLogin();
     }
     __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
-    // Store internals in SDKInternalsRegistry (not visible on instance)
+    // Store internals in SDKInternalsRegistry (not visible on instance).
+    // `folderKey` is meta-tag-only — kept off `UiPathConfig` (which mirrors
+    // user-passed values) and lives here on the runtime registry instead.
     SDKInternalsRegistry.set(this, {
         config: internalConfig,
         context: executionContext,
-        tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager()
+        tokenManager: __classPrivateFieldGet(this, _UiPath_authService, "f").getTokenManager(),
+        folderKey: __classPrivateFieldGet(this, _UiPath_metaFolderKey, "f"),
     });
     // Expose read-only config for user convenience
     this.config = {
@@ -6068,6 +6084,7 @@ _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_ini
 }, _UiPath_loadConfig = function _UiPath_loadConfig() {
     // Load from meta tags
     const metaConfig = loadFromMetaTags();
+    __classPrivateFieldSet(this, _UiPath_metaFolderKey, metaConfig?.folderKey, "f");
     // Merge with any partial config from constructor (constructor overrides meta tags)
     const merged = { ...metaConfig, ...__classPrivateFieldGet(this, _UiPath_partialConfig, "f") };
     if (!isCompleteConfig(merged)) {
@@ -6311,6 +6328,7 @@ class ErrorFactory {
 }
 
 const FOLDER_KEY = 'X-UIPATH-FolderKey';
+const FOLDER_PATH_ENCODED = 'X-UIPATH-FolderPath-Encoded';
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
 const TRACEPARENT = 'traceparent';
 const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
@@ -6457,6 +6475,27 @@ var PaginationType;
 /**
  * Collection of utility functions for working with objects
  */
+/**
+ * Resolves a field value from an object, supporting both direct keys (e.g., '@odata.count')
+ * and dot-separated nested paths (e.g., 'pagination.totalCount').
+ * Direct key match takes priority over nested traversal.
+ */
+function resolveNestedField(data, fieldPath) {
+    if (!data) {
+        return undefined;
+    }
+    if (fieldPath in data) {
+        return data[fieldPath];
+    }
+    if (!fieldPath.includes('.')) {
+        return undefined;
+    }
+    let value = data;
+    for (const part of fieldPath.split('.')) {
+        value = value?.[part];
+    }
+    return value;
+}
 /**
  * Filters out undefined values from an object
  * @param obj The source object
@@ -6716,6 +6755,26 @@ const BUCKET_PAGINATION = {
     /** Field name for continuation token in bucket file metadata response */
     CONTINUATION_TOKEN_FIELD: 'continuationToken'
 };
+/**
+ * SLA Summary pagination constants for page-number-based pagination
+ */
+const SLA_SUMMARY_PAGINATION = {
+    /** Field name for items in SLA summary response */
+    ITEMS_FIELD: 'data',
+    /** Dot-notation path for total count in nested pagination object */
+    TOTAL_COUNT_FIELD: 'pagination.totalCount'
+};
+/**
+ * SLA Summary OFFSET pagination parameter names (page-number style, no skip conversion)
+ */
+const SLA_SUMMARY_OFFSET_PARAMS = {
+    /** Page size parameter name */
+    PAGE_SIZE_PARAM: 'PageSize',
+    /** Page number parameter name (sent directly, not converted to skip) */
+    OFFSET_PARAM: 'PageNumber',
+    /** No count param needed */
+    COUNT_PARAM: undefined
+};
 /**
  * Process Instance pagination constants for token-based pagination
  */
@@ -6766,6 +6825,14 @@ const PROCESS_INSTANCE_TOKEN_PARAMS = {
     TOKEN_PARAM: 'nextPage'
 };
 
+/**
+ * Converts a UTC timestamp string (e.g., "5/8/2026 11:20:17 AM") to ISO 8601 UTC format.
+ * Returns the original value if parsing fails.
+ */
+function toISOUtc(value) {
+    const date = new Date(value + ' UTC');
+    return isNaN(date.getTime()) ? value : date.toISOString();
+}
 /**
  * Transforms data by mapping fields according to the provided field mapping
  * @param data The source data to transform
@@ -7322,7 +7389,8 @@ class PaginationHelpers {
         // Extract and transform items from response
         // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
         const rawItems = Array.isArray(response.data) ? response.data : response.data?.[itemsField];
-        const totalCount = Array.isArray(response.data) ? undefined : response.data?.[totalCountField];
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
         // Parse items - automatically handle JSON string responses
         const parsedItems = typeof rawItems === 'string' ? JSON.parse(rawItems) : (rawItems || []);
         const items = transformFn ? parsedItems.map(transformFn) : parsedItems;
@@ -7443,8 +7511,9 @@ class BaseService {
     constructor(instance, headers) {
         // Private field - not visible via Object.keys() or any reflection
         _BaseService_apiClient.set(this, void 0);
-        const { config, context, tokenManager } = SDKInternalsRegistry.get(instance);
+        const { config, context, tokenManager, folderKey } = SDKInternalsRegistry.get(instance);
         __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager, headers ? { headers } : {}), "f");
+        this.config = { folderKey };
     }
     /**
      * Gets a valid authentication token, refreshing if necessary.
@@ -7563,9 +7632,17 @@ class BaseService {
                 const pageSizeParam = paginationParams?.pageSizeParam || ODATA_OFFSET_PARAMS.PAGE_SIZE_PARAM;
                 const offsetParam = paginationParams?.offsetParam || ODATA_OFFSET_PARAMS.OFFSET_PARAM;
                 const countParam = paginationParams?.countParam || ODATA_OFFSET_PARAMS.COUNT_PARAM;
+                // When true (default), converts pageNumber to a skip/offset value (e.g., page 3 with pageSize 10 → skip 20).
+                // When false, passes pageNumber directly as the offset param — used by APIs that accept a page number instead of a record offset.
+                const convertToSkip = paginationParams?.convertToSkip ?? true;
                 requestParams[pageSizeParam] = limitedPageSize;
-                if (params.pageNumber && params.pageNumber > 1) {
-                    requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                if (convertToSkip) {
+                    if (params.pageNumber && params.pageNumber > 1) {
+                        requestParams[offsetParam] = (params.pageNumber - 1) * limitedPageSize;
+                    }
+                }
+                else {
+                    requestParams[offsetParam] = params.pageNumber || 1;
                 }
                 {
                     requestParams[countParam] = true;
@@ -7596,7 +7673,8 @@ class BaseService {
         // Extract items and metadata
         // Handle both plain array responses and envelope responses ({ value: [...], totalRecordCount: N })
         const items = Array.isArray(response.data) ? response.data : (response.data[itemsField] || []);
-        const totalCount = Array.isArray(response.data) ? undefined : response.data[totalCountField];
+        const rawTotalCount = Array.isArray(response.data) ? undefined : resolveNestedField(response.data, totalCountField);
+        const totalCount = typeof rawTotalCount === 'number' ? rawTotalCount : undefined;
         const continuationToken = response.data[continuationTokenField];
         // Determine if there are more pages
         const hasMore = this.determineHasMorePages(paginationType, {
@@ -7806,6 +7884,17 @@ exports.QueryFilterOperator = void 0;
     QueryFilterOperator["In"] = "in";
     QueryFilterOperator["NotIn"] = "not in";
 })(exports.QueryFilterOperator || (exports.QueryFilterOperator = {}));
+/**
+ * Aggregate functions supported by the Data Fabric query API.
+ */
+exports.EntityAggregateFunction = void 0;
+(function (EntityAggregateFunction) {
+    EntityAggregateFunction["Count"] = "COUNT";
+    EntityAggregateFunction["Sum"] = "SUM";
+    EntityAggregateFunction["Avg"] = "AVG";
+    EntityAggregateFunction["Min"] = "MIN";
+    EntityAggregateFunction["Max"] = "MAX";
+})(exports.EntityAggregateFunction || (exports.EntityAggregateFunction = {}));
 /**
  * Entity type enum
  */
@@ -8395,16 +8484,16 @@ class EntityService extends BaseService {
         return entities;
     }
     /**
-     * Queries entity records with filters, sorting, and pagination
+     * Queries entity records with filters, sorting, aggregates, and pagination
      *
      * @param id - UUID of the entity
-     * @param options - Query options including filterGroup, selectedFields, sortOptions, and pagination
+     * @param options - Query options including filterGroup, selectedFields, sortOptions, aggregates, groupBy, and pagination
      * @returns Promise resolving to {@link NonPaginatedResponse} without pagination options,
      *   or {@link PaginatedResponse} when `pageSize`, `cursor`, or `jumpToPage` are provided
      *
      * @example
      * ```typescript
-     * import { Entities, LogicalOperator, QueryFilterOperator } from '@uipath/uipath-typescript/entities';
+     * import { Entities, LogicalOperator, QueryFilterOperator, EntityAggregateFunction } from '@uipath/uipath-typescript/entities';
      *
      * const entities = new Entities(sdk);
      *
@@ -8428,6 +8517,23 @@ class EntityService extends BaseService {
      * if (page1.hasNextPage) {
      *   const page2 = await entities.queryRecordsById("<entityId>", { cursor: page1.nextCursor });
      * }
+     *
+     * // Aggregate: count of records per status
+     * await entities.queryRecordsById("<entityId>", {
+     *   selectedFields: ["status"],
+     *   groupBy: ["status"],
+     *   aggregates: [
+     *     { function: EntityAggregateFunction.Count, field: "Id", alias: "total" },
+     *   ],
+     * });
+     *
+     * // Aggregate: total sum and average across all records (no grouping)
+     * await entities.queryRecordsById("<entityId>", {
+     *   aggregates: [
+     *     { function: EntityAggregateFunction.Sum, field: "amount", alias: "totalAmount" },
+     *     { function: EntityAggregateFunction.Avg, field: "amount", alias: "avgAmount" },
+     *   ],
+     * });
      * ```
      */
     async queryRecordsById(id, options) {
@@ -8445,7 +8551,7 @@ class EntityService extends BaseService {
                     countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
                 }
             },
-            excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions']
+            excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions', 'aggregates', 'groupBy']
         }, options);
     }
     /**
@@ -9455,6 +9561,41 @@ exports.DebugMode = void 0;
  * Case Instance Types
  * Types and interfaces for Maestro case instance management
  */
+/**
+ * SLA status for a case instance
+ */
+exports.SlaSummaryStatus = void 0;
+(function (SlaSummaryStatus) {
+    /** Case is within SLA deadline */
+    SlaSummaryStatus["ON_TRACK"] = "On Track";
+    /** Case is approaching SLA deadline based on at-risk percentage threshold */
+    SlaSummaryStatus["AT_RISK"] = "At Risk";
+    /** Case has exceeded SLA deadline */
+    SlaSummaryStatus["OVERDUE"] = "Overdue";
+    /** Case instance has completed */
+    SlaSummaryStatus["COMPLETED"] = "Completed";
+    /** SLA status cannot be determined (no SLA deadline defined) */
+    SlaSummaryStatus["UNKNOWN"] = "Unknown";
+})(exports.SlaSummaryStatus || (exports.SlaSummaryStatus = {}));
+/**
+ * Instance status values for case instances and process instances
+ */
+exports.InstanceStatus = void 0;
+(function (InstanceStatus) {
+    /** Instance status not yet populated by the backend */
+    InstanceStatus["UNKNOWN"] = "";
+    InstanceStatus["CANCELLED"] = "Cancelled";
+    InstanceStatus["CANCELING"] = "Canceling";
+    InstanceStatus["COMPLETED"] = "Completed";
+    InstanceStatus["FAULTED"] = "Faulted";
+    InstanceStatus["PAUSED"] = "Paused";
+    InstanceStatus["PAUSING"] = "Pausing";
+    InstanceStatus["PENDING"] = "Pending";
+    InstanceStatus["RESUMING"] = "Resuming";
+    InstanceStatus["RETRYING"] = "Retrying";
+    InstanceStatus["RUNNING"] = "Running";
+    InstanceStatus["UPGRADING"] = "Upgrading";
+})(exports.InstanceStatus || (exports.InstanceStatus = {}));
 /**
  * Case stage task type
  */
@@ -9489,6 +9630,8 @@ exports.EscalationTriggerType = void 0;
 (function (EscalationTriggerType) {
     EscalationTriggerType["SLA_BREACHED"] = "sla-breached";
     EscalationTriggerType["AT_RISK"] = "at-risk";
+    /** Default value when no escalation rule is defined */
+    EscalationTriggerType["NONE"] = "None";
 })(exports.EscalationTriggerType || (exports.EscalationTriggerType = {}));
 /**
  * SLA duration unit
@@ -9556,6 +9699,11 @@ function createCaseInstanceMethods(instanceData, service) {
             if (!instanceData.instanceId)
                 throw new Error('Case instance ID is undefined');
             return service.getActionTasks(instanceData.instanceId, options);
+        },
+        async getSlaSummary(options) {
+            if (!instanceData.instanceId)
+                throw new Error('Case instance ID is undefined');
+            return service.getSlaSummary({ ...options, caseInstanceId: instanceData.instanceId });
         }
     };
 }
@@ -11110,6 +11258,70 @@ class CaseInstancesService extends BaseService {
         };
         return await this.taskService.getAll(enhancedOptions);
     }
+    /**
+     * 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 });
+     * ```
+     */
+    async getSlaSummary(options) {
+        const apiOptions = options ? {
+            ...options,
+            startTimeUtc: options.startTimeUtc?.toISOString(),
+            endTimeUtc: options.endTimeUtc?.toISOString()
+        } : undefined;
+        return PaginationHelpers.getAll({
+            serviceAccess: this.createPaginationServiceAccess(),
+            getEndpoint: () => MAESTRO_ENDPOINTS.INSIGHTS.SLA_SUMMARY,
+            method: HTTP_METHODS.POST,
+            excludeFromPrefix: ['caseInstanceId', 'startTimeUtc', 'endTimeUtc'],
+            transformFn: (item) => ({
+                ...item,
+                slaDueTime: toISOUtc(item.slaDueTime),
+                lastModifiedTime: toISOUtc(item.lastModifiedTime)
+            }),
+            pagination: {
+                paginationType: PaginationType.OFFSET,
+                itemsField: SLA_SUMMARY_PAGINATION.ITEMS_FIELD,
+                totalCountField: SLA_SUMMARY_PAGINATION.TOTAL_COUNT_FIELD,
+                paginationParams: {
+                    pageSizeParam: SLA_SUMMARY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                    offsetParam: SLA_SUMMARY_OFFSET_PARAMS.OFFSET_PARAM,
+                    countParam: SLA_SUMMARY_OFFSET_PARAMS.COUNT_PARAM,
+                    convertToSkip: false
+                }
+            }
+        }, apiOptions);
+    }
 }
 __decorate([
     track('CaseInstances.GetAll')
@@ -11138,7 +11350,115 @@ __decorate([
 __decorate([
     track('CaseInstances.GetActionTasks')
 ], CaseInstancesService.prototype, "getActionTasks", null);
+__decorate([
+    track('CaseInstances.GetSlaSummary')
+], CaseInstancesService.prototype, "getSlaSummary", null);
+
+/**
+ * Validates the `name` argument passed to a `getByName(name, ...)` method.
+ * Trims whitespace and rejects empty/whitespace-only names.
+ *
+ * @param resourceType - Resource label used in error messages (e.g. 'Asset', 'Process')
+ * @param name - Resource name to validate
+ * @returns The trimmed name
+ * @throws ValidationError when `name` is missing or empty after trimming
+ */
+function validateName(resourceType, name) {
+    if (!name) {
+        throw new ValidationError({
+            message: `${resourceType} name is required and cannot be empty.`,
+        });
+    }
+    const trimmed = name.trim();
+    if (!trimmed) {
+        throw new ValidationError({
+            message: `${resourceType} name is required and cannot be empty.`,
+        });
+    }
+    return trimmed;
+}
 
+/**
+ * Encodes a folder path for the `X-UIPATH-FolderPath-Encoded` header.
+ *
+ * Orchestrator decodes this header as **base64-encoded UTF-16 LE bytes**
+ * (see `HttpHeadersProviderExtensions.GetDecoded` + `OrganizationUnitProvider`
+ * in the Orchestrator repo, which call `Encoding.Unicode.GetString(...)`).
+ * URL-encoding is NOT what the server expects — it must be base64-of-UTF-16-LE
+ * bytes.
+ *
+ * @param folderPath - The folder path (e.g. 'Shared/Finance')
+ * @returns Base64 string suitable for the `X-UIPATH-FolderPath-Encoded` header
+ */
+function encodeFolderPathHeader(folderPath) {
+    // Force little-endian regardless of host byte order. `Uint16Array` viewed
+    // as `Uint8Array` would use the host's native order — correct on LE hosts
+    // (x86/ARM-LE) but wrong on BE hosts. `DataView.setUint16(..., true)`
+    // pins LE.
+    const buf = new ArrayBuffer(folderPath.length * 2);
+    const view = new DataView(buf);
+    for (let i = 0; i < folderPath.length; i++) {
+        view.setUint16(i * 2, folderPath.charCodeAt(i), true);
+    }
+    const bytes = new Uint8Array(buf);
+    let binary = '';
+    for (let i = 0; i < bytes.byteLength; i++) {
+        binary += String.fromCharCode(bytes[i]);
+    }
+    // btoa is browser-native; Node 16+ also has it as a global
+    return btoa(binary);
+}
+
+/**
+ * Resolves folder context into the appropriate Orchestrator folder headers.
+ *
+ * Centralized so all folder-scoped methods (e.g. `assets.getByName`,
+ * `processes.getByName`, future Queues/Buckets/Jobs) share one implementation.
+ *
+ * Each input field maps directly to its header — no auto-detection or type
+ * coercion. When multiple fields are supplied, all corresponding headers
+ * are forwarded and the server resolves precedence.
+ *
+ * Routing:
+ * - `folderId` → `X-UIPATH-OrganizationUnitId`
+ * - `folderKey` → `X-UIPATH-FolderKey`
+ * - `folderPath` → `X-UIPATH-FolderPath-Encoded`
+ * - none set + `fallbackFolderKey` → fallback used as `X-UIPATH-FolderKey`
+ * - none set + no fallback → `ValidationError`
+ *
+ * @throws ValidationError when no folder context can be resolved.
+ */
+function resolveFolderHeaders(input) {
+    const { folderId, folderKey, folderPath, resourceType, fallbackFolderKey } = input;
+    const trimmedKey = folderKey?.trim();
+    const trimmedPath = folderPath?.trim();
+    const headers = {};
+    if (folderId !== undefined) {
+        headers[FOLDER_ID] = folderId;
+    }
+    if (trimmedKey) {
+        headers[FOLDER_KEY] = trimmedKey;
+    }
+    if (trimmedPath) {
+        headers[FOLDER_PATH_ENCODED] = encodeFolderPathHeader(trimmedPath);
+    }
+    // No explicit folder context → meta-tag fallback or error.
+    if (Object.keys(headers).length === 0) {
+        if (!fallbackFolderKey) {
+            throw new ValidationError({
+                message: `${resourceType} requires folder context: pass \`folderId\`, \`folderKey\`, or \`folderPath\`, or initialize the SDK with a folder context.`,
+            });
+        }
+        headers[FOLDER_KEY] = fallbackFolderKey;
+    }
+    return createHeaders(headers);
+}
+
+/**
+ * Matches single-quote characters in OData string literals — escaped to `''`
+ * inside the `$filter=Name eq '…'` clause built by `getByNameLookup`.
+ */
+const SINGLE_QUOTE_RE = /'/g;
 /**
  * Base service for services that need folder-specific functionality.
  *
@@ -11172,6 +11492,68 @@ class FolderScopedService extends BaseService {
         }
         return response.data?.value;
     }
+    /**
+     * Look up a single resource by name on a folder-scoped OData collection.
+     *
+     * Shared by `getByName` implementations across services (Assets, Processes, etc).
+     * Handles:
+     * - Name validation via `validateName`
+     * - Folder header resolution via `resolveFolderHeaders` (folderId → ID/key
+     *   header by type, folderPath → encoded path header, falls back to
+     *   init-time `config.folderKey` from the `uipath:folder-key` meta tag)
+     * - OData `$filter=Name eq '…'` with single-quote escaping + `$top=1`
+     * - Empty-result → `NotFoundError` with folder context in the message
+     *
+     * The transform step is caller-provided because each resource has its own
+     * PascalCase → camelCase field mapping.
+     *
+     * @param resourceType - Resource label used in validation + error messages (e.g. 'Asset', 'Process')
+     * @param endpoint - Folder-scoped OData collection endpoint
+     * @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)
+     * @throws ValidationError when inputs are malformed; NotFoundError when no match
+     */
+    async getByNameLookup(resourceType, endpoint, name, options, transform) {
+        const validatedName = validateName(resourceType, name);
+        const { folderId, folderKey, folderPath, ...queryOptions } = options;
+        const headers = resolveFolderHeaders({
+            folderId,
+            folderKey,
+            folderPath,
+            resourceType: `${resourceType}.getByName`,
+            fallbackFolderKey: this.config.folderKey,
+        });
+        const apiOptions = {
+            ...addPrefixToKeys(queryOptions, ODATA_PREFIX, Object.keys(queryOptions)),
+            '$filter': `Name eq '${validatedName.replace(SINGLE_QUOTE_RE, "''")}'`,
+            '$top': '1',
+        };
+        const response = await this.get(endpoint, {
+            headers,
+            params: apiOptions,
+        });
+        const items = response.data?.value;
+        if (!items?.length) {
+            const folderHint = describeFolderForError(folderId, folderKey, folderPath);
+            throw new NotFoundError({
+                message: `${resourceType} '${validatedName}' not found${folderHint}.`,
+            });
+        }
+        return transform(items[0]);
+    }
+}
+/** Renders the supplied folder for a NotFoundError message. */
+function describeFolderForError(folderId, folderKey, folderPath) {
+    const path = folderPath?.trim();
+    if (path)
+        return ` in folder '${path}'`;
+    const key = folderKey?.trim();
+    if (key)
+        return ` in folder (key: ${key})`;
+    if (typeof folderId === 'number')
+        return ` in folder (id: ${folderId})`;
+    return '';
 }
 
 /**
@@ -11269,6 +11651,35 @@ class AssetService extends FolderScopedService {
         const transformedAsset = transformData(pascalToCamelCaseKeys(response.data), AssetMap);
         return transformedAsset;
     }
+    /**
+     * Retrieves a single asset by name.
+     *
+     * @param name - Asset name to search for
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`)
+     * @returns Promise resolving to a single asset
+     * {@link AssetGetResponse}
+     * @example
+     * ```typescript
+     * import { Assets } from '@uipath/uipath-typescript/assets';
+     *
+     * const assets = new Assets(sdk);
+     *
+     * // By folder ID
+     * await assets.getByName('ApiKey', { folderId: 123 });
+     *
+     * // By folder key (GUID)
+     * await assets.getByName('ApiKey', { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+     *
+     * // By folder path
+     * await assets.getByName('ApiKey', { folderPath: 'Shared/Finance' });
+     *
+     * // With expand
+     * await assets.getByName('ApiKey', { folderPath: 'Shared/Finance', expand: 'keyValueList' });
+     * ```
+     */
+    async getByName(name, options = {}) {
+        return this.getByNameLookup('Asset', ASSET_ENDPOINTS.GET_BY_FOLDER, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap));
+    }
 }
 __decorate([
     track('Assets.GetAll')
@@ -11276,6 +11687,9 @@ __decorate([
 __decorate([
     track('Assets.GetById')
 ], AssetService.prototype, "getById", null);
+__decorate([
+    track('Assets.GetByName')
+], AssetService.prototype, "getByName", null);
 
 /**
  * Enum for Asset Value Scope
@@ -12379,7 +12793,7 @@ const ProcessMap = {
 /**
  * Service for interacting with UiPath Orchestrator Processes API
  */
-class ProcessService extends BaseService {
+class ProcessService extends FolderScopedService {
     /**
      * Gets all processes across folders with optional filtering and folder scoping
      *
@@ -12516,6 +12930,35 @@ class ProcessService extends BaseService {
         const transformedProcess = transformData(pascalToCamelCaseKeys(response.data), ProcessMap);
         return transformedProcess;
     }
+    /**
+     * Retrieves a single process by name.
+     *
+     * @param name - Process name to search for
+     * @param options - Folder scoping (`folderId` / `folderKey` / `folderPath`) and optional query parameters (`expand`, `select`)
+     * @returns Promise resolving to a single process
+     * {@link ProcessGetResponse}
+     * @example
+     * ```typescript
+     * import { Processes } from '@uipath/uipath-typescript/processes';
+     *
+     * const processes = new Processes(sdk);
+     *
+     * // By folder ID
+     * await processes.getByName('MyProcess', { folderId: 123 });
+     *
+     * // By folder key (GUID)
+     * await processes.getByName('MyProcess', { folderKey: '5f6dadf1-3677-49dc-8aca-c2999dd4b3ba' });
+     *
+     * // By folder path
+     * await processes.getByName('MyProcess', { folderPath: 'Shared/Finance' });
+     *
+     * // With expand
+     * await processes.getByName('MyProcess', { folderPath: 'Shared/Finance', expand: 'entryPoints' });
+     * ```
+     */
+    async getByName(name, options = {}) {
+        return this.getByNameLookup('Process', PROCESS_ENDPOINTS.GET_ALL, name, options, (raw) => transformData(pascalToCamelCaseKeys(raw), ProcessMap));
+    }
 }
 __decorate([
     track('Processes.GetAll')
@@ -12526,6 +12969,9 @@ __decorate([
 __decorate([
     track('Processes.GetById')
 ], ProcessService.prototype, "getById", null);
+__decorate([
+    track('Processes.GetByName')
+], ProcessService.prototype, "getByName", null);
 
 /**
  * Maps fields for Queue entities to ensure consistent naming
@@ -13003,7 +13449,7 @@ const AgentMap = {
 };
 
 /**
- * Constants for User Service
+ * Constants for User Settings Service
  */
 /**
  * Maps fields for User Settings entities to ensure consistent SDK naming