@uipath/uipath-typescript 1.3.3 → 1.3.5

package/dist/index.umd.js

@@ -4540,6 +4540,7 @@
         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
@@ -4611,6 +4612,7 @@
             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}`,
@@ -9207,7 +9209,7 @@
     // 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";
@@ -10042,6 +10044,8 @@
 
     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
      */
@@ -10095,8 +10099,13 @@
             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
@@ -11400,6 +11409,13 @@
                     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');
@@ -11602,6 +11618,20 @@
         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)
      */
@@ -11664,6 +11694,70 @@
         [exports.FieldDisplayType.AutoNumber]: exports.EntityFieldDataType.AUTO_NUMBER,
         [exports.FieldDisplayType.Relationship]: exports.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 = {
+        [exports.EntityFieldDataType.STRING]: {
+            [EntityFieldConstraint.LengthLimit]: { min: 1, max: 4000 },
+        },
+        [exports.EntityFieldDataType.MULTILINE_TEXT]: {
+            [EntityFieldConstraint.LengthLimit]: { min: 1, max: 10000 },
+        },
+        [exports.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 },
+        },
+        [exports.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 },
+        },
+        [exports.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 },
+        },
+        [exports.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 },
+        },
+        [exports.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
      */
@@ -11952,6 +12046,8 @@
         /**
          * 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
@@ -11979,6 +12075,27 @@
             });
             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
          *
@@ -12240,6 +12357,13 @@
          *   { 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
          */
@@ -12313,6 +12437,17 @@
          *   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
          */
@@ -12356,6 +12491,21 @@
                     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 }),
@@ -12365,6 +12515,7 @@
                         ...(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 } }),
                     };
                 });
             }
@@ -12414,24 +12565,27 @@
                 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
          */
@@ -12472,11 +12626,16 @@
         /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
         buildSchemaFieldPayload(field) {
             this.validateName(field.fieldName, 'field');
-            const mapping = EntitySchemaFieldTypeMap[field.type ?? exports.EntityFieldDataType.STRING];
+            const fieldType = field.type ?? exports.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,
@@ -12489,6 +12648,107 @@
                 ...(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 exports.EntityFieldDataType.STRING:
+                    return { lengthLimit: field.lengthLimit ?? defaults.STRING_LENGTH_LIMIT };
+                case exports.EntityFieldDataType.MULTILINE_TEXT:
+                    return { lengthLimit: field.lengthLimit ?? defaults.MULTILINE_TEXT_LENGTH_LIMIT };
+                case exports.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 exports.EntityFieldDataType.BOOLEAN:
+                    return { lengthLimit: defaults.BOOLEAN_LENGTH_LIMIT };
+                case exports.EntityFieldDataType.DATE:
+                case exports.EntityFieldDataType.DATETIME_WITH_TZ:
+                    return { lengthLimit: defaults.DATE_LENGTH_LIMIT };
+                case exports.EntityFieldDataType.INTEGER:
+                case exports.EntityFieldDataType.BIG_INTEGER:
+                    return {
+                        maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                        minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                    };
+                case exports.EntityFieldDataType.FLOAT:
+                case exports.EntityFieldDataType.DOUBLE:
+                    return {
+                        decimalPrecision: field.decimalPrecision ?? defaults.DECIMAL_PRECISION,
+                        maxValue: field.maxValue ?? defaults.NUMERIC_MAX_VALUE,
+                        minValue: field.minValue ?? defaults.NUMERIC_MIN_VALUE,
+                    };
+                case exports.EntityFieldDataType.FILE:
+                case exports.EntityFieldDataType.RELATIONSHIP:
+                    // UNIQUEIDENTIFIER fixed lengthLimit (300)
+                    return { lengthLimit: defaults.UNIQUEIDENTIFIER_LENGTH_LIMIT };
+                case exports.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_]+/, '');
@@ -12531,6 +12791,9 @@
     __decorate([
         track('Entities.DeleteRecordsById')
     ], EntityService.prototype, "deleteRecordsById", null);
+    __decorate([
+        track('Entities.DeleteRecordById')
+    ], EntityService.prototype, "deleteRecordById", null);
     __decorate([
         track('Entities.GetAll')
     ], EntityService.prototype, "getAll", null);
@@ -15155,6 +15418,13 @@
                     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);
+            },
         };
     }
     /**
@@ -15654,6 +15924,41 @@
             }
             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
@@ -15741,6 +16046,9 @@
     __decorate([
         track('Jobs.Resume')
     ], JobService.prototype, "resume", null);
+    __decorate([
+        track('Jobs.Restart')
+    ], JobService.prototype, "restart", null);
 
     /**
      * Enum for job sub-state
@@ -16449,6 +16757,260 @@
         FeedbackStatus[FeedbackStatus["Dismissed"] = 2] = "Dismissed";
     })(exports.FeedbackStatus || (exports.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
      *
@@ -16539,6 +17101,7 @@
     exports.DEFAULT_ITEMS_FIELD = DEFAULT_ITEMS_FIELD;
     exports.DEFAULT_PAGE_SIZE = DEFAULT_PAGE_SIZE;
     exports.DEFAULT_TOTAL_COUNT_FIELD = DEFAULT_TOTAL_COUNT_FIELD;
+    exports.DuFramework = index;
     exports.ErrorType = ErrorType;
     exports.ExchangeMap = ExchangeMap;
     exports.HttpStatus = HttpStatus;