feat(assets): add updateValueById for PUT /odata/Assets({key})

Adds Assets.updateValueById(id, folderId, newValue) that fetches the
asset to determine its valueType, validates the newValue runtime type
matches (Text/Integer/Bool only), and PUTs the update while preserving
the asset's name, scope, and description. Unsupported valueTypes
(Credential, Secret) throw ValidationError.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: maninder-uipath

docs/oauth-scopes.md

@@ -9,6 +9,7 @@ This page lists the specific OAuth scopes required in external app for each SDK
 | `getAll()` | `OR.Assets` or `OR.Assets.Read` |
 | `getById()` | `OR.Assets` or `OR.Assets.Read` |
 | `getByName()` | `OR.Assets` or `OR.Assets.Read` |
+| `updateValueById()` | `OR.Assets` or `OR.Assets.Write` |
 
 ## Jobs
 

src/models/orchestrator/assets.models.ts

@@ -1,4 +1,4 @@
-import { AssetGetAllOptions, AssetGetResponse, AssetGetByIdOptions, AssetGetByNameOptions } from './assets.types';
+import { AssetGetAllOptions, AssetGetResponse, AssetGetByIdOptions, AssetGetByNameOptions, AssetNewValue } from './assets.types';
 import { PaginatedResponse, NonPaginatedResponse, HasPaginationOptions } from '../../utils/pagination';
 
 /**
@@ -90,4 +90,47 @@ export interface AssetServiceModel {
    * ```
    */
   getByName(name: string, options?: AssetGetByNameOptions): Promise<AssetGetResponse>;
+
+  /**
+   * Updates the value of an existing asset by ID.
+   *
+   * Fetches the asset internally to determine its type, then updates only the value while
+   * preserving the asset's name, scope, and description.
+   *
+   * **Supported value types:** `Text`, `Integer`, and `Bool` only. Other types
+   * (`Credential`, `Secret`) throw a `ValidationError`.
+   *
+   * The `newValue` runtime type must match the asset's `valueType`:
+   * - `Text` → `string`
+   * - `Integer` → `number` (integer)
+   * - `Bool` → `boolean`
+   *
+   * A `ValidationError` is thrown when the `newValue` type does not match.
+   *
+   * Returns void; the API does not return the updated asset, so call
+   * {@link AssetServiceModel.getById} or {@link AssetServiceModel.getByName}
+   * if you need the refreshed value.
+   *
+   * @param id - Asset ID
+   * @param folderId - Required folder ID the asset belongs to
+   * @param newValue - New value to apply (string for `Text`, number for `Integer`, boolean for `Bool`)
+   * @returns Promise resolving when the asset has been updated
+   *
+   * @example
+   * ```typescript
+   * import { Assets } from '@uipath/uipath-typescript/assets';
+   *
+   * const assets = new Assets(sdk);
+   *
+   * // Update a Text asset
+   * await assets.updateValueById(<assetId>, <folderId>, 'new-value');
+   *
+   * // Update an Integer asset
+   * await assets.updateValueById(<assetId>, <folderId>, 42);
+   *
+   * // Update a Bool asset
+   * await assets.updateValueById(<assetId>, <folderId>, true);
+   * ```
+   */
+  updateValueById(id: number, folderId: number, newValue: AssetNewValue): Promise<void>;
 }

src/models/orchestrator/assets.types.ts

@@ -73,3 +73,13 @@ export interface AssetGetByIdOptions extends BaseOptions {}
  * Options for getting a single asset by name
  */
 export interface AssetGetByNameOptions extends FolderScopedOptions {}
+
+/**
+ * New value accepted by {@link AssetServiceModel.updateValueById}.
+ *
+ * The runtime type must match the asset's `valueType`:
+ * - `Text` → `string`
+ * - `Integer` → `number`
+ * - `Bool` → `boolean`
+ */
+export type AssetNewValue = string | number | boolean;

src/services/orchestrator/assets/assets.ts

@@ -1,5 +1,5 @@
 import { FolderScopedService } from '../../folder-scoped';
-import { AssetGetResponse, AssetGetAllOptions, AssetGetByIdOptions, AssetGetByNameOptions } from '../../../models/orchestrator/assets.types';
+import { AssetGetResponse, AssetGetAllOptions, AssetGetByIdOptions, AssetGetByNameOptions, AssetNewValue, AssetValueType } from '../../../models/orchestrator/assets.types';
 import { AssetServiceModel } from '../../../models/orchestrator/assets.models';
 import { addPrefixToKeys, pascalToCamelCaseKeys, transformData } from '../../../utils/transform';
 import { createHeaders } from '../../../utils/http/headers';
@@ -12,6 +12,7 @@ import { PaginatedResponse, NonPaginatedResponse, HasPaginationOptions } from '.
 import { PaginationHelpers } from '../../../utils/pagination/helpers';
 import { PaginationType } from '../../../utils/pagination/internal-types';
 import { track } from '../../../core/telemetry';
+import { ValidationError } from '../../../core/errors';
 
 /**
  * Service for interacting with UiPath Orchestrator Assets API
@@ -155,4 +156,116 @@ export class AssetService extends FolderScopedService implements AssetServiceMod
       (raw) => transformData(pascalToCamelCaseKeys(raw), AssetMap),
     );
   }
+
+  /**
+   * Updates the value of an existing asset by ID.
+   *
+   * Fetches the asset internally to determine its type, then updates only the value while
+   * preserving the asset's name, scope, and description.
+   *
+   * **Supported value types:** `Text`, `Integer`, and `Bool` only. Other types
+   * (`Credential`, `Secret`) throw a `ValidationError`.
+   *
+   * The `newValue` runtime type must match the asset's `valueType`:
+   * - `Text` → `string`
+   * - `Integer` → `number` (integer)
+   * - `Bool` → `boolean`
+   *
+   * A `ValidationError` is thrown when the `newValue` type does not match.
+   *
+   * Returns void; the API does not return the updated asset, so call
+   * {@link AssetService.getById} or {@link AssetService.getByName} if you need
+   * the refreshed value.
+   *
+   * @param id - Asset ID
+   * @param folderId - Required folder ID the asset belongs to
+   * @param newValue - New value to apply (string for `Text`, number for `Integer`, boolean for `Bool`)
+   * @returns Promise resolving when the asset has been updated
+   *
+   * @example
+   * ```typescript
+   * import { Assets } from '@uipath/uipath-typescript/assets';
+   *
+   * const assets = new Assets(sdk);
+   *
+   * // Update a Text asset
+   * await assets.updateValueById(<assetId>, <folderId>, 'new-value');
+   *
+   * // Update an Integer asset
+   * await assets.updateValueById(<assetId>, <folderId>, 42);
+   *
+   * // Update a Bool asset
+   * await assets.updateValueById(<assetId>, <folderId>, true);
+   * ```
+   */
+  @track('Assets.UpdateValueById')
+  async updateValueById(id: number, folderId: number, newValue: AssetNewValue): Promise<void> {
+    if (!id) {
+      throw new ValidationError({ message: 'id is required for updateValueById' });
+    }
+    if (!folderId) {
+      throw new ValidationError({ message: 'folderId is required for updateValueById' });
+    }
+    if (newValue === null || newValue === undefined) {
+      throw new ValidationError({ message: 'newValue is required for updateValueById' });
+    }
+
+    const existing = await this.getById(id, folderId);
+
+    const valueField = resolveValueField(id, existing.valueType, newValue);
+
+    const headers = createHeaders({ [FOLDER_ID]: folderId });
+    const body: Record<string, unknown> = {
+      Id: id,
+      Name: existing.name,
+      ValueScope: existing.valueScope,
+      ValueType: existing.valueType,
+      Description: existing.description,
+      [valueField]: newValue,
+    };
+
+    await this.put(
+      ASSET_ENDPOINTS.GET_BY_ID(id),
+      body,
+      { headers },
+    );
+  }
+}
+
+/**
+ * Maps the asset's `valueType` to the PUT body field carrying the new value, validating
+ * that the new value's runtime type matches the asset type.
+ */
+function resolveValueField(
+  id: number,
+  valueType: AssetValueType,
+  newValue: AssetNewValue,
+): 'StringValue' | 'IntValue' | 'BoolValue' {
+  switch (valueType) {
+    case AssetValueType.Text:
+      if (typeof newValue !== 'string') {
+        throw new ValidationError({
+          message: `Asset ${id} has valueType Text; newValue must be a string, got ${typeof newValue}`,
+        });
+      }
+      return 'StringValue';
+    case AssetValueType.Integer:
+      if (typeof newValue !== 'number' || !Number.isInteger(newValue)) {
+        throw new ValidationError({
+          message: `Asset ${id} has valueType Integer; newValue must be an integer number, got ${typeof newValue}`,
+        });
+      }
+      return 'IntValue';
+    case AssetValueType.Bool:
+      if (typeof newValue !== 'boolean') {
+        throw new ValidationError({
+          message: `Asset ${id} has valueType Bool; newValue must be a boolean, got ${typeof newValue}`,
+        });
+      }
+      return 'BoolValue';
+    default:
+      throw new ValidationError({
+        message: `updateValueById only supports Text, Integer, or Bool assets; asset ${id} has valueType ${valueType}`,
+      });
+  }
 }

tests/integration/shared/orchestrator/assets.integration.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { getServices, getTestConfig, setupUnifiedTests, InitMode } from '../../config/unified-setup';
-import { isNotFoundError } from '../../../../src/core/errors';
+import { isNotFoundError, isValidationError } from '../../../../src/core/errors';
 
 const modes: InitMode[] = ['v0', 'v1'];
 
@@ -77,7 +77,7 @@ describe.each(modes)('Orchestrator Assets - Integration Tests [%s]', (mode) => {
       expect(result.name).toBeDefined();
       expect(result.valueType).toBeDefined();
       expect(typeof result.name).toBe('string');
-    });
+  });
   });
 
   describe('getByName', () => {
@@ -159,6 +159,56 @@ describe.each(modes)('Orchestrator Assets - Integration Tests [%s]', (mode) => {
     });
   });
 
+  describe('updateValueById', () => {
+    it('should update an existing text asset and persist the change', async () => {
+      const { assets } = getServices();
+      const config = getTestConfig();
+
+      if (!config.folderId) {
+        throw new Error('INTEGRATION_TEST_FOLDER_ID must be configured to test updateValueById');
+      }
+      const folderId = Number(config.folderId);
+
+      // Find an existing Text-type asset in the folder so we can update it safely
+      const allAssets = await assets.getAll({
+        folderId,
+        pageSize: 20,
+        filter: "ValueType eq 'Text'",
+      });
+
+      if (allAssets.items.length === 0) {
+        throw new Error('No Text-type assets available in the configured folder to exercise updateValueById');
+      }
+
+      const target = allAssets.items[0];
+      const previousValue = target.value ?? '';
+      const newValue = `sdk-test-${Date.now()}`;
+
+      const result = await assets.updateValueById(target.id, folderId, newValue);
+      expect(result).toBeUndefined();
+
+      const refreshed = await assets.getById(target.id, folderId);
+      expect(refreshed.value).toBe(newValue);
+
+      // Restore the asset so the suite is idempotent
+      await assets.updateValueById(target.id, folderId, previousValue);
+    });
+
+    it('should throw ValidationError for invalid id', async () => {
+      const { assets } = getServices();
+      const config = getTestConfig();
+
+      if (!config.folderId) {
+        throw new Error('INTEGRATION_TEST_FOLDER_ID must be configured to test updateValueById');
+      }
+      const folderId = Number(config.folderId);
+
+      await expect(
+        assets.updateValueById(0, folderId, 'irrelevant'),
+      ).rejects.toSatisfy(isValidationError);
+    });
+  });
+
   describe('Asset structure validation', () => {
     it('should have expected fields in asset objects', async () => {
       const { assets } = getServices();