@uipath/uipath-typescript 1.3.3 → 1.3.5

package/dist/index.mjs

@@ -4536,6 +4536,7 @@ const JOB_ENDPOINTS = {
     GET_BY_KEY: (identifier) => `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${identifier})`,
     STOP: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.StopJobs`,
     RESUME: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.ResumeJob`,
+    RESTART: `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.RestartJob`,
 };
 /**
  * Orchestrator Asset Service Endpoints
@@ -4607,6 +4608,7 @@ const DATA_FABRIC_ENDPOINTS = {
         BATCH_INSERT_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/insert-batch`,
         UPDATE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update/${recordId}`,
         UPDATE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/update-batch`,
+        DELETE_RECORD_BY_ID: (entityId, recordId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete/${recordId}`,
         DELETE_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
         UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
         DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
@@ -5448,7 +5450,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.3";
+const SDK_VERSION = "1.3.5";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -6283,6 +6285,8 @@ class ErrorFactory {
 
 const FOLDER_KEY = 'X-UIPATH-FolderKey';
 const FOLDER_ID = 'X-UIPATH-OrganizationUnitId';
+const TRACEPARENT = 'traceparent';
+const UIPATH_TRACEPARENT_ID = 'x-uipath-traceparent-id';
 /**
  * Content type constants for HTTP requests/responses
  */
@@ -6336,8 +6340,13 @@ class ApiClient {
         if (isFormData) {
             delete defaultHeaders['Content-Type'];
         }
+        const traceId = crypto.randomUUID().replace(/-/g, '');
+        const spanId = crypto.randomUUID().replace(/-/g, '').slice(0, 16);
+        const traceparentValue = `00-${traceId}-${spanId}-01`;
         const headers = {
             ...defaultHeaders,
+            [TRACEPARENT]: traceparentValue,
+            [UIPATH_TRACEPARENT_ID]: traceparentValue,
             ...options.headers
         };
         // Convert params to URLSearchParams
@@ -7641,6 +7650,13 @@ function createEntityMethods(entityData, service) {
                 throw new Error('Entity ID is undefined');
             return service.deleteRecordsById(entityData.id, recordIds, options);
         },
+        async deleteRecord(recordId) {
+            if (!entityData.id)
+                throw new Error('Entity ID is undefined');
+            if (!recordId)
+                throw new Error('Record ID is undefined');
+            return service.deleteRecordById(entityData.id, recordId);
+        },
         async getAllRecords(options) {
             if (!entityData.id)
                 throw new Error('Entity ID is undefined');
@@ -7737,13 +7753,13 @@ var EntityFieldDataType;
 /**
  * Logical operator for combining query filter groups
  */
-var LogicalOperator;
+var LogicalOperator$1;
 (function (LogicalOperator) {
     /** Combine conditions with AND — all conditions must match */
     LogicalOperator[LogicalOperator["And"] = 0] = "And";
     /** Combine conditions with OR — any condition must match */
     LogicalOperator[LogicalOperator["Or"] = 1] = "Or";
-})(LogicalOperator || (LogicalOperator = {}));
+})(LogicalOperator$1 || (LogicalOperator$1 = {}));
 /**
  * Comparison operators for entity query filters.
  * Not all operators are valid for all field types.
@@ -7843,6 +7859,20 @@ function createParams(paramsObj = {}) {
     return params;
 }
 
+/**
+ * Names of the per-field SQL constraint properties (i.e. the contents of `sqlType`
+ * excluding its `name`). Used internally to validate user-supplied constraints
+ * against the set of constraints that each `EntityFieldDataType` accepts.
+ *
+ * Enum values match the corresponding property names on `EntityCreateFieldOptions`.
+ */
+var EntityFieldConstraint;
+(function (EntityFieldConstraint) {
+    EntityFieldConstraint["LengthLimit"] = "lengthLimit";
+    EntityFieldConstraint["MaxValue"] = "maxValue";
+    EntityFieldConstraint["MinValue"] = "minValue";
+    EntityFieldConstraint["DecimalPrecision"] = "decimalPrecision";
+})(EntityFieldConstraint || (EntityFieldConstraint = {}));
 /**
  * Entity field data types (SQL types from API)
  */
@@ -7905,6 +7935,70 @@ const FieldDisplayTypeToDataType = {
     [FieldDisplayType.AutoNumber]: EntityFieldDataType.AUTO_NUMBER,
     [FieldDisplayType.Relationship]: EntityFieldDataType.RELATIONSHIP,
 };
+/**
+ * Default and fixed sqlType constraint values applied when the user does not provide them.
+ * The API requires these to be present on field creation — without them the field
+ * is stored in an incomplete state, causing "Field type cannot be changed" errors
+ * when the UI later tries to edit advanced options.
+ */
+const ENTITY_FIELD_CONSTRAINT_DEFAULTS = {
+    STRING_LENGTH_LIMIT: 200,
+    MULTILINE_TEXT_LENGTH_LIMIT: 200,
+    /** Fixed (non-overridable) length limit on DECIMAL payloads*/
+    DECIMAL_LENGTH_LIMIT: 1000,
+    DECIMAL_PRECISION: 2,
+    /** Fixed (non-overridable) length limit for BIT (BOOLEAN) fields */
+    BOOLEAN_LENGTH_LIMIT: 100,
+    /** Fixed (non-overridable) length limit for DATE / DATETIMEOFFSET fields */
+    DATE_LENGTH_LIMIT: 1000,
+    /** Fixed (non-overridable) length limit for UNIQUEIDENTIFIER-backed FILE and RELATIONSHIP fields */
+    UNIQUEIDENTIFIER_LENGTH_LIMIT: 300,
+    /** Fixed (non-overridable) length limit for CHOICE_SET_MULTIPLE fields */
+    CHOICE_SET_MULTIPLE_LENGTH_LIMIT: 4000,
+    NUMERIC_MAX_VALUE: 1000000000000,
+    NUMERIC_MIN_VALUE: -1e12,
+};
+/**
+ * Per-field-type spec describing which {@link EntityFieldConstraint}s the user
+ * may supply on create / update, and the inclusive value range for each.
+ *
+ * Source of truth: the platform's `Constants.cs` constraint table. Keys absent
+ * from a type's spec are not user-configurable for that type; passing one
+ * throws a `ValidationError`. Field types absent from this map (BOOLEAN, DATE,
+ * DATETIME, DATETIME_WITH_TZ, FILE, RELATIONSHIP, UUID, CHOICE_SET_SINGLE,
+ * CHOICE_SET_MULTIPLE, AUTO_NUMBER) accept no user-supplied constraints.
+ */
+const ENTITY_FIELD_CONSTRAINT_SPEC = {
+    [EntityFieldDataType.STRING]: {
+        [EntityFieldConstraint.LengthLimit]: { min: 1, max: 4000 },
+    },
+    [EntityFieldDataType.MULTILINE_TEXT]: {
+        [EntityFieldConstraint.LengthLimit]: { min: 1, max: 10000 },
+    },
+    [EntityFieldDataType.INTEGER]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+    },
+    [EntityFieldDataType.BIG_INTEGER]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+    },
+    [EntityFieldDataType.DECIMAL]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+    [EntityFieldDataType.FLOAT]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+    [EntityFieldDataType.DOUBLE]: {
+        [EntityFieldConstraint.MaxValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.MinValue]: { min: -Number.MAX_SAFE_INTEGER, max: Number.MAX_SAFE_INTEGER },
+        [EntityFieldConstraint.DecimalPrecision]: { min: 0, max: 10 },
+    },
+};
 /**
  * Maps SQL field types to friendly display names
  */
@@ -8193,6 +8287,8 @@ class EntityService extends BaseService {
     /**
      * Deletes data from an entity by entity ID
      *
+     * Note: Records deleted using deleteRecordsById will not trigger Data Fabric trigger events. Use {@link deleteRecordById} if you need trigger events to fire for the deleted record.
+     *
      * @param entityId - UUID of the entity
      * @param recordIds - Array of record UUIDs to delete
      * @param options - Delete options
@@ -8220,6 +8316,27 @@ class EntityService extends BaseService {
         });
         return response.data;
     }
+    /**
+     * Deletes a single record from an entity by entity ID and record ID
+     *
+     * Note: Data Fabric supports trigger events only on individual deletes, not on deleting multiple records.
+     * Use this method if you need trigger events to fire for the deleted record.
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record to delete
+     * @returns Promise resolving to void on success
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * await entities.deleteRecordById("<entityId>", "<recordId>");
+     * ```
+     */
+    async deleteRecordById(entityId, recordId) {
+        await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE_RECORD_BY_ID(entityId, recordId));
+    }
     /**
      * Gets all entities in the system
      *
@@ -8481,6 +8598,13 @@ class EntityService extends BaseService {
      *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true },
      *   { fieldName: "price", type: EntityFieldDataType.INTEGER, defaultValue: "0" },
      * ], { displayName: "Product Catalog", description: "Our product catalog", isRbacEnabled: true });
+     *
+     * // With advanced sqlType constraints (lengthLimit, decimalPrecision, maxValue, minValue) and defaultValue
+     * const ordersId = await entities.create("orders", [
+     *   { fieldName: "product_name", type: EntityFieldDataType.STRING, isRequired: true, isUnique: true, lengthLimit: 500 },
+     *   { fieldName: "price", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   { fieldName: "quantity", type: EntityFieldDataType.INTEGER, maxValue: 10000, minValue: 1, defaultValue: "0" },
+     * ]);
      * ```
      * @internal
      */
@@ -8554,6 +8678,17 @@ class EntityService extends BaseService {
      *   updateFields: [{ id: "<fieldId>", displayName: "Unit Price", isRequired: true }],
      *   displayName: "Price Catalog",
      * });
+     *
+     * // Add a STRING/DECIMAL field with explicit advanced sqlType constraints and defaultValue
+     * await entities.updateById("<entityId>", {
+     *   addFields: [
+     *     { fieldName: "summary", type: EntityFieldDataType.STRING, lengthLimit: 500, defaultValue: "summary" },
+     *     { fieldName: "amount", type: EntityFieldDataType.DECIMAL, decimalPrecision: 4, maxValue: 999999, minValue: 0 },
+     *   ],
+     *   updateFields: [
+     *     { id: "<fieldId>", lengthLimit: 1000 },
+     *   ],
+     * });
      * ```
      * @internal
      */
@@ -8597,6 +8732,21 @@ class EntityService extends BaseService {
                 const update = updateMap.get(f.id ?? '');
                 if (!update)
                     return f;
+                const constraintUpdate = {
+                    ...(update.lengthLimit !== undefined && { lengthLimit: update.lengthLimit }),
+                    ...(update.maxValue !== undefined && { maxValue: update.maxValue }),
+                    ...(update.minValue !== undefined && { minValue: update.minValue }),
+                    ...(update.decimalPrecision !== undefined && { decimalPrecision: update.decimalPrecision }),
+                };
+                const hasConstraintUpdate = Object.keys(constraintUpdate).length > 0;
+                if (hasConstraintUpdate) {
+                    if (!f.sqlType) {
+                        throw new ValidationError({
+                            message: `Cannot update constraints on field '${f.name}' (id: ${f.id}) — the field is missing sqlType metadata in the entity definition.`,
+                        });
+                    }
+                    this.validateFieldConstraints(this.resolveFieldDataType(f), update, f.name);
+                }
                 return {
                     ...f,
                     ...(update.displayName !== undefined && { displayName: update.displayName }),
@@ -8606,6 +8756,7 @@ class EntityService extends BaseService {
                     ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
                     ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
                     ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
+                    ...(hasConstraintUpdate && f.sqlType && { sqlType: { ...f.sqlType, ...constraintUpdate } }),
                 };
             });
         }
@@ -8655,24 +8806,27 @@ class EntityService extends BaseService {
             let transformedField = transformData(field, EntityMap);
             // Map field type: prefer fieldDisplayType for types that share SQL types (File, ChoiceSet, AutoNumber)
             if (transformedField.fieldDataType?.name) {
-                const displayTypeMapped = transformedField.fieldDisplayType
-                    ? FieldDisplayTypeToDataType[transformedField.fieldDisplayType]
-                    : undefined;
-                if (displayTypeMapped) {
-                    transformedField.fieldDataType.name = displayTypeMapped;
-                }
-                else {
-                    const rawSqlTypeName = field.sqlType?.name;
-                    const mapped = rawSqlTypeName ? EntityFieldTypeMap[rawSqlTypeName] : undefined;
-                    if (mapped) {
-                        transformedField.fieldDataType.name = mapped;
-                    }
+                const mapped = this.tryResolveFieldDataType(transformedField.fieldDisplayType, field.sqlType?.name);
+                if (mapped) {
+                    transformedField.fieldDataType.name = mapped;
                 }
             }
             this.transformNestedReferences(transformedField);
             return transformedField;
         });
     }
+    /**
+     * Resolves an {@link EntityFieldDataType} from a field's `fieldDisplayType` and
+     * raw SQL type name. Prefers `fieldDisplayType` to disambiguate types that
+     * share a SQL type (FILE, CHOICE_SET_*, AUTO_NUMBER, RELATIONSHIP); falls back
+     * to the SQL-type-name mapping. Returns `undefined` if neither resolves.
+     */
+    tryResolveFieldDataType(fieldDisplayType, sqlTypeName) {
+        const displayMapped = fieldDisplayType ? FieldDisplayTypeToDataType[fieldDisplayType] : undefined;
+        if (displayMapped)
+            return displayMapped;
+        return sqlTypeName ? EntityFieldTypeMap[sqlTypeName] : undefined;
+    }
     /**
      * Transforms nested reference objects in field metadata
      */
@@ -8713,11 +8867,16 @@ class EntityService extends BaseService {
     /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
     buildSchemaFieldPayload(field) {
         this.validateName(field.fieldName, 'field');
-        const mapping = EntitySchemaFieldTypeMap[field.type ?? EntityFieldDataType.STRING];
+        const fieldType = field.type ?? EntityFieldDataType.STRING;
+        this.validateFieldConstraints(fieldType, field, field.fieldName);
+        const mapping = EntitySchemaFieldTypeMap[fieldType];
         return {
             name: field.fieldName,
             displayName: field.displayName ?? field.fieldName,
-            sqlType: { name: mapping.sqlTypeName },
+            sqlType: {
+                name: mapping.sqlTypeName,
+                ...this.buildSqlTypeConstraints(fieldType, field),
+            },
             fieldDisplayType: mapping.fieldDisplayType,
             description: field.description ?? '',
             isRequired: field.isRequired ?? false,
@@ -8730,6 +8889,107 @@ class EntityService extends BaseService {
             ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
         };
     }
+    /**
+     * Derives the user-facing {@link EntityFieldDataType} for a field on the raw
+     * API response. Throws if the field's `fieldDisplayType` and `sqlType.name`
+     * are both unmappable.
+     */
+    resolveFieldDataType(f) {
+        const mapped = this.tryResolveFieldDataType(f.fieldDisplayType, f.sqlType?.name);
+        if (!mapped) {
+            throw new ValidationError({
+                message: `Cannot determine field type for '${f.name}' (id: ${f.id}) — sqlType '${f.sqlType?.name ?? '(missing)'}' and fieldDisplayType '${f.fieldDisplayType ?? '(missing)'}' are both unrecognized.`,
+            });
+        }
+        return mapped;
+    }
+    /**
+     * Validates that the user-supplied constraint properties on a field are
+     * supported by the field's data type. Throws a `ValidationError` listing
+     * any unsupported properties.
+     */
+    validateFieldConstraints(type, field, fieldName) {
+        const spec = ENTITY_FIELD_CONSTRAINT_SPEC[type] ?? {};
+        const supported = Object.keys(spec);
+        const provided = Object.values(EntityFieldConstraint).filter(name => field[name] !== undefined);
+        const unsupported = provided.filter(p => !(p in spec));
+        if (unsupported.length > 0) {
+            const allowedDesc = supported.length > 0 ? supported.join(', ') : 'none';
+            throw new ValidationError({
+                message: `Field '${fieldName}' of type ${type} does not accept ${unsupported.join(', ')}. Allowed constraints for this type: ${allowedDesc}.`,
+            });
+        }
+        // Range check: each user-supplied constraint must be within its allowed bounds.
+        for (const name of provided) {
+            const range = spec[name];
+            const value = field[name];
+            if (range && value !== undefined && (value < range.min || value > range.max)) {
+                throw new ValidationError({
+                    message: `Field '${fieldName}' of type ${type} has ${name} ${value} out of range [${range.min}, ${range.max}].`,
+                });
+            }
+        }
+        // Cross-field check: when both bounds are user-supplied in the same call,
+        // minValue must be strictly less than maxValue.
+        if (field.minValue !== undefined && field.maxValue !== undefined && field.minValue >= field.maxValue) {
+            throw new ValidationError({
+                message: `Field '${fieldName}' of type ${type} has minValue ${field.minValue} >= maxValue ${field.maxValue}. minValue must be strictly less than maxValue.`,
+            });
+        }
+    }
+    /**
+     * Returns the sqlType constraint fields for a given field type.
+     *
+     * The API requires specific constraint properties to be set per SQL type;
+     * without them the field is stored in an incomplete state, causing
+     * "Field type cannot be changed" errors when the UI later tries to edit
+     * advanced options. User-supplied values from `EntityCreateFieldOptions`
+     * override the defaults where the type accepts overrides.
+     */
+    buildSqlTypeConstraints(type, field) {
+        const defaults = ENTITY_FIELD_CONSTRAINT_DEFAULTS;
+        switch (type) {
+            case EntityFieldDataType.STRING:
+                return { lengthLimit: field.lengthLimit ?? defaults.STRING_LENGTH_LIMIT };
+            case EntityFieldDataType.MULTILINE_TEXT:
+                return { lengthLimit: field.lengthLimit ?? defaults.MULTILINE_TEXT_LENGTH_LIMIT };
+            case EntityFieldDataType.DECIMAL:
+                return {
+                    lengthLimit: defaults.DECIMAL_LENGTH_LIMIT,
+                    decimalPrecision: field.decimalPrecision ?? defaults.DECIMAL_PRECISION,
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.BOOLEAN:
+                return { lengthLimit: defaults.BOOLEAN_LENGTH_LIMIT };
+            case EntityFieldDataType.DATE:
+            case EntityFieldDataType.DATETIME_WITH_TZ:
+                return { lengthLimit: defaults.DATE_LENGTH_LIMIT };
+            case EntityFieldDataType.INTEGER:
+            case EntityFieldDataType.BIG_INTEGER:
+                return {
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.FLOAT:
+            case EntityFieldDataType.DOUBLE:
+                return {
+                    decimalPrecision: field.decimalPrecision ?? defaults.DECIMAL_PRECISION,
+                    maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                    minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                };
+            case EntityFieldDataType.FILE:
+            case EntityFieldDataType.RELATIONSHIP:
+                // UNIQUEIDENTIFIER fixed lengthLimit (300)
+                return { lengthLimit: defaults.UNIQUEIDENTIFIER_LENGTH_LIMIT };
+            case EntityFieldDataType.CHOICE_SET_MULTIPLE:
+                // CHOICE_SET_MULTIPLE fixed lengthLimit (4000)
+                return { lengthLimit: defaults.CHOICE_SET_MULTIPLE_LENGTH_LIMIT };
+            default:
+                // UUID, CHOICE_SET_SINGLE, AUTO_NUMBER, DATETIME — (sqlType: { name })
+                return {};
+        }
+    }
     validateName(name, context) {
         if (name.length < 3 || name.length > 100 || !/^[a-zA-Z]\w*$/.test(name)) {
             const suggestion = name.replace(/\W/g, '').replace(/^[0-9_]+/, '');
@@ -8772,6 +9032,9 @@ __decorate([
 __decorate([
     track('Entities.DeleteRecordsById')
 ], EntityService.prototype, "deleteRecordsById", null);
+__decorate([
+    track('Entities.DeleteRecordById')
+], EntityService.prototype, "deleteRecordById", null);
 __decorate([
     track('Entities.GetAll')
 ], EntityService.prototype, "getAll", null);
@@ -11396,6 +11659,13 @@ function createJobMethods(jobData, service) {
                 throw new Error('Job folderId is undefined');
             return service.resume(jobData.key, jobData.folderId, options);
         },
+        async restart() {
+            if (!jobData.key)
+                throw new Error('Job key is undefined');
+            if (!jobData.folderId)
+                throw new Error('Job folderId is undefined');
+            return service.restart(jobData.key, jobData.folderId);
+        },
     };
 }
 /**
@@ -11895,6 +12165,41 @@ class JobService extends FolderScopedService {
         }
         await this.post(JOB_ENDPOINTS.RESUME, body, { headers });
     }
+    /**
+     * Restarts a job in a final state (Successful, Faulted, or Stopped).
+     *
+     * Creates a **new** job execution from a previously successful, faulted, or stopped job.
+     * The new job has its own unique `key`, starts in `Pending` state, and uses
+     * the same process and input arguments as the original job.
+     *
+     * To monitor the new job's progress, poll with {@link getById}
+     * using the returned job's key until the state reaches a final value.
+     *
+     * @param jobKey - The unique key (GUID) of the job to restart
+     * @param folderId - The folder ID where the job resides
+     * @returns Promise resolving to the new {@link JobGetResponse} with full job details
+     *
+     * @example
+     * ```typescript
+     * // Restart a faulted job
+     * const newJob = await jobs.restart(<jobKey>, <folderId>);
+     * console.log(newJob.state); // 'Pending'
+     * console.log(newJob.key);   // new job key (different from original)
+     * ```
+     */
+    async restart(jobKey, folderId) {
+        if (!jobKey) {
+            throw new ValidationError({ message: 'jobKey is required for restart' });
+        }
+        if (!folderId) {
+            throw new ValidationError({ message: 'folderId is required for restart' });
+        }
+        const [jobId] = await this.resolveJobKeys([jobKey], folderId);
+        const headers = createHeaders({ [FOLDER_ID]: folderId });
+        const response = await this.post(JOB_ENDPOINTS.RESTART, { jobId }, { headers });
+        const rawJob = transformData(pascalToCamelCaseKeys(response.data), JobMap);
+        return createJobWithMethods(rawJob, this);
+    }
     /**
      * Downloads the output file content via the Attachments API.
      * 1. Fetches blob access info from the attachment using AttachmentService
@@ -11982,6 +12287,9 @@ __decorate([
 __decorate([
     track('Jobs.Resume')
 ], JobService.prototype, "resume", null);
+__decorate([
+    track('Jobs.Restart')
+], JobService.prototype, "restart", null);
 
 /**
  * Enum for job sub-state
@@ -12690,6 +12998,260 @@ var FeedbackStatus;
     FeedbackStatus[FeedbackStatus["Dismissed"] = 2] = "Dismissed";
 })(FeedbackStatus || (FeedbackStatus = {}));
 
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var DocumentActionPriority;
+(function (DocumentActionPriority) {
+    DocumentActionPriority["Low"] = "Low";
+    DocumentActionPriority["Medium"] = "Medium";
+    DocumentActionPriority["High"] = "High";
+    DocumentActionPriority["Critical"] = "Critical";
+})(DocumentActionPriority || (DocumentActionPriority = {}));
+var DocumentActionStatus;
+(function (DocumentActionStatus) {
+    DocumentActionStatus["Unassigned"] = "Unassigned";
+    DocumentActionStatus["Pending"] = "Pending";
+    DocumentActionStatus["Completed"] = "Completed";
+})(DocumentActionStatus || (DocumentActionStatus = {}));
+var DocumentActionType;
+(function (DocumentActionType) {
+    DocumentActionType["Validation"] = "Validation";
+    DocumentActionType["Classification"] = "Classification";
+})(DocumentActionType || (DocumentActionType = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ProjectProperties;
+(function (ProjectProperties) {
+    ProjectProperties["IsPredefined"] = "IsPredefined";
+    ProjectProperties["SupportsTags"] = "SupportsTags";
+    ProjectProperties["SupportsVersions"] = "SupportsVersions";
+    ProjectProperties["IsSplittingEnabled"] = "IsSplittingEnabled";
+})(ProjectProperties || (ProjectProperties = {}));
+var ProjectType;
+(function (ProjectType) {
+    ProjectType["Classic"] = "Classic";
+    ProjectType["Modern"] = "Modern";
+    ProjectType["IXP"] = "IXP";
+    ProjectType["Unknown"] = "Unknown";
+})(ProjectType || (ProjectType = {}));
+var ResourceStatus;
+(function (ResourceStatus) {
+    ResourceStatus["Unknown"] = "Unknown";
+    ResourceStatus["NotStarted"] = "NotStarted";
+    ResourceStatus["ExportInProgress"] = "ExportInProgress";
+    ResourceStatus["ExportCompleted"] = "ExportCompleted";
+    ResourceStatus["InProgress"] = "InProgress";
+    ResourceStatus["Suspended"] = "Suspended";
+    ResourceStatus["Resuming"] = "Resuming";
+    ResourceStatus["Available"] = "Available";
+    ResourceStatus["Error"] = "Error";
+    ResourceStatus["Deleting"] = "Deleting";
+})(ResourceStatus || (ResourceStatus = {}));
+var ResourceType;
+(function (ResourceType) {
+    ResourceType["Specialized"] = "Specialized";
+    ResourceType["Generative"] = "Generative";
+    ResourceType["Custom"] = "Custom";
+    ResourceType["Unknown"] = "Unknown";
+})(ResourceType || (ResourceType = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var MarkupType;
+(function (MarkupType) {
+    MarkupType["Unknown"] = "Unknown";
+    MarkupType["Circled"] = "Circled";
+    MarkupType["Underlined"] = "Underlined";
+    MarkupType["Strikethrough"] = "Strikethrough";
+})(MarkupType || (MarkupType = {}));
+var ProcessingSource;
+(function (ProcessingSource) {
+    ProcessingSource["Unknown"] = "Unknown";
+    ProcessingSource["Ocr"] = "Ocr";
+    ProcessingSource["Pdf"] = "Pdf";
+    ProcessingSource["PlainText"] = "PlainText";
+    ProcessingSource["PdfAndOcr"] = "PdfAndOcr";
+})(ProcessingSource || (ProcessingSource = {}));
+var Rotation;
+(function (Rotation) {
+    Rotation["None"] = "None";
+    Rotation["Rotated90"] = "Rotated90";
+    Rotation["Rotated180"] = "Rotated180";
+    Rotation["Rotated270"] = "Rotated270";
+    Rotation["Other"] = "Other";
+})(Rotation || (Rotation = {}));
+var SectionType;
+(function (SectionType) {
+    SectionType["Vertical"] = "Vertical";
+    SectionType["Paragraph"] = "Paragraph";
+    SectionType["Header"] = "Header";
+    SectionType["Footer"] = "Footer";
+    SectionType["Table"] = "Table";
+})(SectionType || (SectionType = {}));
+var TextType;
+(function (TextType) {
+    TextType["Unknown"] = "Unknown";
+    TextType["Text"] = "Text";
+    TextType["Checkbox"] = "Checkbox";
+    TextType["Handwriting"] = "Handwriting";
+    TextType["Barcode"] = "Barcode";
+    TextType["QRcode"] = "QRcode";
+    TextType["Stamp"] = "Stamp";
+    TextType["Logo"] = "Logo";
+    TextType["Circle"] = "Circle";
+    TextType["Underline"] = "Underline";
+    TextType["Cut"] = "Cut";
+})(TextType || (TextType = {}));
+var WordGroupType;
+(function (WordGroupType) {
+    WordGroupType["Sentence"] = "Sentence";
+    WordGroupType["TableCell"] = "TableCell";
+    WordGroupType["TableRowEnd"] = "TableRowEnd";
+    WordGroupType["Heading"] = "Heading";
+    WordGroupType["Other"] = "Other";
+})(WordGroupType || (WordGroupType = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ModelKind;
+(function (ModelKind) {
+    ModelKind["Classifier"] = "Classifier";
+    ModelKind["Extractor"] = "Extractor";
+})(ModelKind || (ModelKind = {}));
+var ModelType;
+(function (ModelType) {
+    ModelType["IXP"] = "IXP";
+    ModelType["Modern"] = "Modern";
+    ModelType["Predefined"] = "Predefined";
+})(ModelType || (ModelType = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ClassifierDocumentTypeType;
+(function (ClassifierDocumentTypeType) {
+    ClassifierDocumentTypeType["FormsAi"] = "FormsAi";
+    ClassifierDocumentTypeType["SemiStructuredAi"] = "SemiStructuredAi";
+    ClassifierDocumentTypeType["Helix"] = "Helix";
+    ClassifierDocumentTypeType["Unknown"] = "Unknown";
+})(ClassifierDocumentTypeType || (ClassifierDocumentTypeType = {}));
+var CreateTaskPriority;
+(function (CreateTaskPriority) {
+    CreateTaskPriority["Low"] = "Low";
+    CreateTaskPriority["Medium"] = "Medium";
+    CreateTaskPriority["High"] = "High";
+    CreateTaskPriority["Critical"] = "Critical";
+})(CreateTaskPriority || (CreateTaskPriority = {}));
+var GptFieldType;
+(function (GptFieldType) {
+    GptFieldType["Address"] = "Address";
+    GptFieldType["Boolean"] = "Boolean";
+    GptFieldType["Date"] = "Date";
+    GptFieldType["Name"] = "Name";
+    GptFieldType["Number"] = "Number";
+    GptFieldType["Text"] = "Text";
+})(GptFieldType || (GptFieldType = {}));
+var ValidationDisplayMode;
+(function (ValidationDisplayMode) {
+    ValidationDisplayMode["Classic"] = "Classic";
+    ValidationDisplayMode["Compact"] = "Compact";
+})(ValidationDisplayMode || (ValidationDisplayMode = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ResultsDataSource;
+(function (ResultsDataSource) {
+    ResultsDataSource["Automatic"] = "Automatic";
+    ResultsDataSource["Manual"] = "Manual";
+    ResultsDataSource["ManuallyChanged"] = "ManuallyChanged";
+    ResultsDataSource["Defaulted"] = "Defaulted";
+    ResultsDataSource["External"] = "External";
+})(ResultsDataSource || (ResultsDataSource = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["Equals"] = "Equals";
+    ComparisonOperator["NotEquals"] = "NotEquals";
+    ComparisonOperator["Greater"] = "Greater";
+    ComparisonOperator["Less"] = "Less";
+    ComparisonOperator["GreaterOrEqual"] = "GreaterOrEqual";
+    ComparisonOperator["LessOrEqual"] = "LessOrEqual";
+})(ComparisonOperator || (ComparisonOperator = {}));
+var Criticality;
+(function (Criticality) {
+    Criticality["Must"] = "Must";
+    Criticality["Should"] = "Should";
+})(Criticality || (Criticality = {}));
+var FieldType;
+(function (FieldType) {
+    FieldType["Text"] = "Text";
+    FieldType["Number"] = "Number";
+    FieldType["Date"] = "Date";
+    FieldType["Name"] = "Name";
+    FieldType["Address"] = "Address";
+    FieldType["Keyword"] = "Keyword";
+    FieldType["Set"] = "Set";
+    FieldType["Boolean"] = "Boolean";
+    FieldType["Table"] = "Table";
+    FieldType["Internal"] = "Internal";
+    FieldType["FieldGroup"] = "FieldGroup";
+    FieldType["MonetaryQuantity"] = "MonetaryQuantity";
+})(FieldType || (FieldType = {}));
+var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "AND";
+    LogicalOperator["OR"] = "OR";
+})(LogicalOperator || (LogicalOperator = {}));
+var RuleType;
+(function (RuleType) {
+    RuleType["Mandatory"] = "Mandatory";
+    RuleType["PossibleValues"] = "PossibleValues";
+    RuleType["Regex"] = "Regex";
+    RuleType["StartsWith"] = "StartsWith";
+    RuleType["EndsWith"] = "EndsWith";
+    RuleType["FixedLength"] = "FixedLength";
+    RuleType["IsNumeric"] = "IsNumeric";
+    RuleType["IsDate"] = "IsDate";
+    RuleType["IsEmail"] = "IsEmail";
+    RuleType["Contains"] = "Contains";
+    RuleType["Expression"] = "Expression";
+    RuleType["TableExpression"] = "TableExpression";
+    RuleType["IsEmpty"] = "IsEmpty";
+})(RuleType || (RuleType = {}));
+
+// Auto-generated from the OpenAPI spec — do not edit manually.
+var ActionStatus;
+(function (ActionStatus) {
+    ActionStatus["Unassigned"] = "Unassigned";
+    ActionStatus["Pending"] = "Pending";
+    ActionStatus["Completed"] = "Completed";
+})(ActionStatus || (ActionStatus = {}));
+
+var index = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    get ActionStatus () { return ActionStatus; },
+    get ClassifierDocumentTypeType () { return ClassifierDocumentTypeType; },
+    get ComparisonOperator () { return ComparisonOperator; },
+    get CreateTaskPriority () { return CreateTaskPriority; },
+    get Criticality () { return Criticality; },
+    get DocumentActionPriority () { return DocumentActionPriority; },
+    get DocumentActionStatus () { return DocumentActionStatus; },
+    get DocumentActionType () { return DocumentActionType; },
+    get FieldType () { return FieldType; },
+    get GptFieldType () { return GptFieldType; },
+    get LogicalOperator () { return LogicalOperator; },
+    get MarkupType () { return MarkupType; },
+    get ModelKind () { return ModelKind; },
+    get ModelType () { return ModelType; },
+    get ProcessingSource () { return ProcessingSource; },
+    get ProjectProperties () { return ProjectProperties; },
+    get ProjectType () { return ProjectType; },
+    get ResourceStatus () { return ResourceStatus; },
+    get ResourceType () { return ResourceType; },
+    get ResultsDataSource () { return ResultsDataSource; },
+    get Rotation () { return Rotation; },
+    get RuleType () { return RuleType; },
+    get SectionType () { return SectionType; },
+    get TextType () { return TextType; },
+    get ValidationDisplayMode () { return ValidationDisplayMode; },
+    get WordGroupType () { return WordGroupType; }
+});
+
 /**
  * Asset resolution utilities for UiPath Coded Apps
  *
@@ -12765,4 +13327,4 @@ function getAppBase() {
     return getMetaTagContent(UiPathMetaTags.APP_BASE) || '/';
 }
 
-export { APP_NAME, AgentMap, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, CitationErrorType, ConversationMap, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, ExchangeMap, FeedbackRating, FeedbackStatus, FieldDisplayType, HttpStatus, InputStreamSpeechSensitivity, InterruptType, JobPriority, JobSourceType, JobState, JobSubState, JobType, JoinType, LogicalOperator, MAX_PAGE_SIZE, MessageMap, MessageRole, NetworkError, NotFoundError, PackageSourceType, PackageType, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, QueryFilterOperator, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, RuntimeType, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, SLADurationUnit, ServerError, ServerlessJobType, SortOrder, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, TaskUserType, UNKNOWN$1 as UNKNOWN, UiPath, UiPathError, UiPathMetaTags, UserSettingsMap, VERSION, ValidationError, createAgentWithMethods, createCaseInstanceWithMethods, createConversationWithMethods, createEntityWithMethods, createJobWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getAppBase, getAsset, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, loadFromMetaTags, telemetryClient, track, trackEvent };
+export { APP_NAME, AgentMap, AssetValueScope, AssetValueType, AuthenticationError, AuthorizationError, BucketOptions, CLOUD_CLIENT_ID, CLOUD_ORGANIZATION_NAME, CLOUD_REDIRECT_URI, CLOUD_ROLE_NAME, CLOUD_TENANT_NAME, CLOUD_URL, CONNECTION_STRING, CitationErrorType, ConversationMap, DEFAULT_ITEMS_FIELD, DEFAULT_PAGE_SIZE, DEFAULT_TOTAL_COUNT_FIELD, DataDirectionType, DebugMode, index as DuFramework, EntityFieldDataType, EntityType, ErrorType, EscalationActionType, EscalationRecipientScope, EscalationTriggerType, ExchangeMap, FeedbackRating, FeedbackStatus, FieldDisplayType, HttpStatus, InputStreamSpeechSensitivity, InterruptType, JobPriority, JobSourceType, JobState, JobSubState, JobType, JoinType, LogicalOperator$1 as LogicalOperator, MAX_PAGE_SIZE, MessageMap, MessageRole, NetworkError, NotFoundError, PackageSourceType, PackageType, ProcessIncidentSeverity, ProcessIncidentStatus, ProcessIncidentType, QueryFilterOperator, RateLimitError, ReferenceType, RemoteControlAccess, RobotSize, RuntimeType, SDK_LOGGER_NAME, SDK_RUN_EVENT, SDK_SERVICE_NAME, SDK_VERSION, SERVICE, SLADurationUnit, ServerError, ServerlessJobType, SortOrder, StageTaskType, StartStrategy, StopStrategy, TargetFramework, TaskActivityType, TaskPriority, TaskSlaCriteria, TaskSlaStatus, TaskSourceName, TaskStatus, TaskType, TaskUserType, UNKNOWN$1 as UNKNOWN, UiPath, UiPathError, UiPathMetaTags, UserSettingsMap, VERSION, ValidationError, createAgentWithMethods, createCaseInstanceWithMethods, createConversationWithMethods, createEntityWithMethods, createJobWithMethods, createProcessInstanceWithMethods, createProcessWithMethods, createTaskWithMethods, getAppBase, getAsset, getErrorDetails, getLimitedPageSize, isAuthenticationError, isAuthorizationError, isNetworkError, isNotFoundError, isRateLimitError, isServerError, isUiPathError, isValidationError, loadFromMetaTags, telemetryClient, track, trackEvent };