@uipath/uipath-typescript 1.3.4 → 1.3.6

package/dist/index.umd.js

@@ -5028,6 +5028,7 @@
     const GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
     class AuthService {
         constructor(config, executionContext) {
+            this.skipAcrValues = false;
             // Only use stored OAuth context when completing an active callback (URL has ?code=).
             // If stored context exists but we're NOT in a callback, it's stale from a
             // failed/abandoned flow (e.g. scope mismatch, invalid redirect URI) and must
@@ -5119,6 +5120,14 @@
         getTokenManager() {
             return this.tokenManager;
         }
+        /**
+         * Enables the UiPath login picker during OAuth sign-in.
+         *
+         * @internal
+         */
+        setMultiLogin() {
+            this.skipAcrValues = true;
+        }
         /**
          * Authenticates the user based on the provided SDK configuration.
          * This method handles OAuth 2.0 authentication flow only.
@@ -5320,7 +5329,10 @@
                 scope: params.scope + ' offline_access',
                 state: params.state || this.generateCodeVerifier().slice(0, 16)
             });
-            return `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}&acr_values=${acrValues}`;
+            const authorizeUrl = `${this.config.baseUrl}/${IDENTITY_ENDPOINTS.AUTHORIZE}?${queryParams.toString()}`;
+            return this.skipAcrValues
+                ? authorizeUrl
+                : `${authorizeUrl}&acr_values=${acrValues}`;
         }
         /**
          * Exchanges the authorization code for an access token and automatically updates the current token
@@ -9209,7 +9221,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.4";
+    const SDK_VERSION = "1.3.6";
     const VERSION = "Version";
     const SERVICE = "Service";
     const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -9589,7 +9601,7 @@
         return hasAnyValue ? config : null;
     }
 
-    var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_initializeWithConfig, _UiPath_loadConfig;
+    var _UiPath_instances, _UiPath_config, _UiPath_authService, _UiPath_initialized, _UiPath_partialConfig, _UiPath_multiLogin, _UiPath_initializeWithConfig, _UiPath_loadConfig;
     /**
      * UiPath - Core SDK class for authentication and configuration management.
      *
@@ -9629,6 +9641,7 @@
             _UiPath_authService.set(this, void 0);
             _UiPath_initialized.set(this, false);
             _UiPath_partialConfig.set(this, void 0);
+            _UiPath_multiLogin.set(this, false);
             // Load configuration from meta tags
             const configFromMetaTags = loadFromMetaTags();
             // Merge configuration: constructor config overrides meta tags
@@ -9679,6 +9692,15 @@
                 throw new Error(`Failed to initialize UiPath SDK: ${errorMessage}`);
             }
         }
+        /**
+         * Enables the UiPath login picker during OAuth sign-in.
+         *
+         * @internal
+         */
+        setMultiLogin() {
+            __classPrivateFieldSet(this, _UiPath_multiLogin, true, "f");
+            __classPrivateFieldGet(this, _UiPath_authService, "f")?.setMultiLogin();
+        }
         /**
          * Check if the SDK has been initialized
          */
@@ -9750,7 +9772,7 @@
             __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
         }
     };
-    _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = 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_instances = new WeakSet(), _UiPath_initializeWithConfig = function _UiPath_initializeWithConfig(config) {
         // Validate and normalize the configuration
         validateConfig(config);
         const hasSecretAuth = hasSecretConfig(config);
@@ -9767,6 +9789,9 @@
         });
         const executionContext = new ExecutionContext();
         __classPrivateFieldSet(this, _UiPath_authService, new AuthService(internalConfig, executionContext), "f");
+        if (__classPrivateFieldGet(this, _UiPath_multiLogin, "f")) {
+            __classPrivateFieldGet(this, _UiPath_authService, "f").setMultiLogin();
+        }
         __classPrivateFieldSet(this, _UiPath_config, internalConfig, "f");
         // Store internals in SDKInternalsRegistry (not visible on instance)
         SDKInternalsRegistry.set(this, {
@@ -11618,6 +11643,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)
      */
@@ -11680,6 +11719,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
      */
@@ -12279,6 +12382,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
          */
@@ -12352,6 +12462,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
          */
@@ -12395,6 +12516,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 }),
@@ -12404,6 +12540,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 } }),
                     };
                 });
             }
@@ -12453,24 +12590,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
          */
@@ -12511,11 +12651,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,
@@ -12528,6 +12673,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_]+/, '');
@@ -16536,6 +16782,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
      *
@@ -16626,6 +17126,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;