@uipath/uipath-typescript 1.3.4 → 1.3.6

package/dist/index.mjs

@@ -5024,6 +5024,7 @@ class TokenManager {
 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
@@ -5115,6 +5116,14 @@ class AuthService {
     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.
@@ -5316,7 +5325,10 @@ class AuthService {
             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
@@ -5450,7 +5462,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.4";
+const SDK_VERSION = "1.3.6";
 const VERSION = "Version";
 const SERVICE = "Service";
 const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -5830,7 +5842,7 @@ function loadFromMetaTags() {
     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.
  *
@@ -5870,6 +5882,7 @@ let UiPath$1 = class UiPath {
         _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
@@ -5920,6 +5933,15 @@ let UiPath$1 = class UiPath {
             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
      */
@@ -5991,7 +6013,7 @@ let UiPath$1 = class UiPath {
         __classPrivateFieldGet(this, _UiPath_authService, "f")?.updateToken(tokenInfo);
     }
 };
-_UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_initialized = new WeakMap(), _UiPath_partialConfig = new WeakMap(), _UiPath_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);
@@ -6008,6 +6030,9 @@ _UiPath_config = new WeakMap(), _UiPath_authService = new WeakMap(), _UiPath_ini
     });
     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, {
@@ -7753,13 +7778,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.
@@ -7859,6 +7884,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)
  */
@@ -7921,6 +7960,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
  */
@@ -8520,6 +8623,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
      */
@@ -8593,6 +8703,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
      */
@@ -8636,6 +8757,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 }),
@@ -8645,6 +8781,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 } }),
                 };
             });
         }
@@ -8694,24 +8831,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
      */
@@ -8752,11 +8892,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,
@@ -8769,6 +8914,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_]+/, '');
@@ -12777,6 +13023,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
  *
@@ -12852,4 +13352,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 };