@uipath/uipath-typescript 1.2.2 → 1.3.1

package/dist/index.umd.js

@@ -4522,6 +4522,7 @@
      */
     const JOB_ENDPOINTS = {
         GET_ALL: `${ORCHESTRATOR_BASE}/odata/Jobs`,
+        GET_BY_KEY: (identifier) => `${ORCHESTRATOR_BASE}/odata/Jobs/UiPath.Server.Configuration.OData.GetByKey(identifier=${identifier})`,
     };
     /**
      * Orchestrator Asset Service Endpoints
@@ -4574,6 +4575,12 @@
     /**
      * Data Fabric Service Endpoints
      */
+    /**
+     * Default folder key used for tenant-level Data Fabric entities.
+     * Tenant-level entities are not scoped to a folder; this is the
+     * conventional placeholder value the API expects.
+     */
+    const DATA_FABRIC_TENANT_FOLDER_ID = '00000000-0000-0000-0000-000000000000';
     /**
      * Data Fabric Entity Service Endpoints
      */
@@ -4588,6 +4595,11 @@
             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_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/delete-batch`,
+            UPSERT: `${DATAFABRIC_BASE}/api/Entity`,
+            DELETE: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}`,
+            UPDATE_METADATA: (entityId) => `${DATAFABRIC_BASE}/api/Entity/${entityId}/metadata`,
+            QUERY_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/query`,
+            BULK_UPLOAD_BY_ID: (entityId) => `${DATAFABRIC_BASE}/api/EntityService/entity/${entityId}/bulk-upload`,
             DOWNLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
             UPLOAD_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
             DELETE_ATTACHMENT: (entityId, recordId, fieldName) => `${DATAFABRIC_BASE}/api/Attachment/entity/${entityId}/${recordId}/${fieldName}`,
@@ -9176,7 +9188,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.2.2";
+    const SDK_VERSION = "1.3.1";
     const VERSION = "Version";
     const SERVICE = "Service";
     const CLOUD_ORGANIZATION_NAME = "CloudOrganizationName";
@@ -9565,7 +9577,7 @@
      *
      * Supports two usage patterns:
      * 1. Full config in constructor — for server-side or explicit configuration
-     * 2. No config / partial config — loads from meta tags injected by @uipath/coded-apps plugin
+     * 2. No config / partial config — loads from meta tags injected by @uipath/coded-apps-dev plugin
      *
      * @example
      * ```typescript
@@ -10031,15 +10043,11 @@
 
     class ApiClient {
         constructor(config, executionContext, tokenManager, clientConfig = {}) {
-            this.defaultHeaders = {};
             this.config = config;
             this.executionContext = executionContext;
             this.clientConfig = clientConfig;
             this.tokenManager = tokenManager;
         }
-        setDefaultHeaders(headers) {
-            this.defaultHeaders = { ...this.defaultHeaders, ...headers };
-        }
         /**
          * Gets a valid authentication token, refreshing if necessary.
          * Used internally for API requests and exposed for services that need manual auth headers.
@@ -10055,7 +10063,6 @@
             return {
                 'Authorization': `Bearer ${token}`,
                 'Content-Type': CONTENT_TYPES.JSON,
-                ...this.defaultHeaders,
                 ...this.clientConfig.headers
             };
         }
@@ -11111,6 +11118,8 @@
          *
          * @param instance - UiPath SDK instance providing authentication and configuration.
          *                    Services receive this via dependency injection in the modular pattern.
+         * @param headers - Optional default headers to include in every request (e.g. `x-uipath-external-user-id` for
+         *                  CAS external-app auth)
          *
          * @example
          * ```typescript
@@ -11130,11 +11139,11 @@
          * const entities = new Entities(sdk);
          * ```
          */
-        constructor(instance) {
+        constructor(instance, headers) {
             // Private field - not visible via Object.keys() or any reflection
             _BaseService_apiClient.set(this, void 0);
             const { config, context, tokenManager } = SDKInternalsRegistry.get(instance);
-            __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager), "f");
+            __classPrivateFieldSet(this, _BaseService_apiClient, new ApiClient(config, context, tokenManager, headers ? { headers } : {}), "f");
         }
         /**
          * Gets a valid authentication token, refreshing if necessary.
@@ -11393,27 +11402,41 @@
                     throw new Error('Entity ID is undefined');
                 return service.deleteAttachment(entityData.id, recordId, fieldName);
             },
+            async queryRecords(options) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.queryRecordsById(entityData.id, options);
+            },
+            async importRecords(file) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.importRecordsById(entityData.id, file);
+            },
             async insert(data, options) {
                 return this.insertRecord(data, options);
             },
             async batchInsert(data, options) {
                 return this.insertRecords(data, options);
             },
-            async update(data, options) {
-                return this.updateRecords(data, options);
-            },
-            async delete(recordIds, options) {
-                return this.deleteRecords(recordIds, options);
-            },
             async getRecords(options) {
                 return this.getAllRecords(options);
-            }
+            },
+            async delete() {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.deleteById(entityData.id);
+            },
+            async update(options) {
+                if (!entityData.id)
+                    throw new Error('Entity ID is undefined');
+                return service.updateById(entityData.id, options);
+            },
         };
     }
     /**
-     * Creates an actionable entity metadata by combining entity with operational methods
+     * Creates an actionable entity by combining entity metadata with data and management methods
      *
-     * @param entityData - Entity metadata
+     * @param entityMetadata - Entity metadata
      * @param service - The entity service instance
      * @returns Entity metadata with added methods
      */
@@ -11423,42 +11446,7 @@
     }
 
     /**
-     * Creates query parameters object from key-value pairs, filtering out undefined values
-     * @param paramsObj - Object containing parameter key-value pairs
-     * @returns Parameters object with undefined values filtered out
-     *
-     * @example
-     * ```typescript
-     * // Entity service parameters
-     * const params = createParams({
-     *   start: 0,
-     *   limit: 10,
-     *   expansionLevel: 1
-     * });
-     *
-     * // With optional/undefined values (automatically filtered)
-     * const params = createParams({
-     *   start: options.start,        // Could be undefined
-     *   limit: options.limit,        // Could be undefined
-     *   expansionLevel: options.expansionLevel  // Could be undefined
-     * });
-     *
-     * // Empty params
-     * const params = createParams();
-     * ```
-     */
-    function createParams(paramsObj = {}) {
-        const params = {};
-        for (const [key, value] of Object.entries(paramsObj)) {
-            if (value !== undefined && value !== null) {
-                params[key] = value;
-            }
-        }
-        return params;
-    }
-
-    /**
-     * Entity field type names
+     * Entity field data type names (SQL-level types returned by the API)
      */
     exports.EntityFieldDataType = void 0;
     (function (EntityFieldDataType) {
@@ -11474,7 +11462,41 @@
         EntityFieldDataType["BOOLEAN"] = "BOOLEAN";
         EntityFieldDataType["BIG_INTEGER"] = "BIG_INTEGER";
         EntityFieldDataType["MULTILINE_TEXT"] = "MULTILINE_TEXT";
+        EntityFieldDataType["FILE"] = "FILE";
+        EntityFieldDataType["CHOICE_SET_SINGLE"] = "CHOICE_SET_SINGLE";
+        EntityFieldDataType["CHOICE_SET_MULTIPLE"] = "CHOICE_SET_MULTIPLE";
+        EntityFieldDataType["AUTO_NUMBER"] = "AUTO_NUMBER";
+        EntityFieldDataType["RELATIONSHIP"] = "RELATIONSHIP";
     })(exports.EntityFieldDataType || (exports.EntityFieldDataType = {}));
+    /**
+     * Logical operator for combining query filter groups
+     */
+    exports.LogicalOperator = void 0;
+    (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";
+    })(exports.LogicalOperator || (exports.LogicalOperator = {}));
+    /**
+     * Comparison operators for entity query filters.
+     * Not all operators are valid for all field types.
+     */
+    exports.QueryFilterOperator = void 0;
+    (function (QueryFilterOperator) {
+        QueryFilterOperator["Equals"] = "=";
+        QueryFilterOperator["NotEquals"] = "!=";
+        QueryFilterOperator["GreaterThan"] = ">";
+        QueryFilterOperator["LessThan"] = "<";
+        QueryFilterOperator["GreaterThanOrEqual"] = ">=";
+        QueryFilterOperator["LessThanOrEqual"] = "<=";
+        QueryFilterOperator["Contains"] = "contains";
+        QueryFilterOperator["NotContains"] = "not contains";
+        QueryFilterOperator["StartsWith"] = "startswith";
+        QueryFilterOperator["EndsWith"] = "endswith";
+        QueryFilterOperator["In"] = "in";
+        QueryFilterOperator["NotIn"] = "not in";
+    })(exports.QueryFilterOperator || (exports.QueryFilterOperator = {}));
     /**
      * Entity type enum
      */
@@ -11520,6 +11542,41 @@
         JoinType["LeftJoin"] = "LeftJoin";
     })(exports.JoinType || (exports.JoinType = {}));
 
+    /**
+     * Creates query parameters object from key-value pairs, filtering out undefined values
+     * @param paramsObj - Object containing parameter key-value pairs
+     * @returns Parameters object with undefined values filtered out
+     *
+     * @example
+     * ```typescript
+     * // Entity service parameters
+     * const params = createParams({
+     *   start: 0,
+     *   limit: 10,
+     *   expansionLevel: 1
+     * });
+     *
+     * // With optional/undefined values (automatically filtered)
+     * const params = createParams({
+     *   start: options.start,        // Could be undefined
+     *   limit: options.limit,        // Could be undefined
+     *   expansionLevel: options.expansionLevel  // Could be undefined
+     * });
+     *
+     * // Empty params
+     * const params = createParams();
+     * ```
+     */
+    function createParams(paramsObj = {}) {
+        const params = {};
+        for (const [key, value] of Object.entries(paramsObj)) {
+            if (value !== undefined && value !== null) {
+                params[key] = value;
+            }
+        }
+        return params;
+    }
+
     /**
      * Entity field data types (SQL types from API)
      */
@@ -11538,6 +11595,7 @@
         SqlFieldType["DECIMAL"] = "DECIMAL";
         SqlFieldType["MULTILINE"] = "MULTILINE";
     })(SqlFieldType || (SqlFieldType = {}));
+
     /**
      * Maps fields for Entities
      */
@@ -11547,6 +11605,40 @@
         sqlType: 'fieldDataType',
         fieldDefinition: 'fieldMetaData'
     };
+    /**
+     * Maps EntityFieldDataType values to the API field payload components for create/update operations
+     */
+    const EntitySchemaFieldTypeMap = {
+        [exports.EntityFieldDataType.UUID]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.STRING]: { sqlTypeName: SqlFieldType.NVARCHAR, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.INTEGER]: { sqlTypeName: SqlFieldType.INT, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.DATETIME]: { sqlTypeName: SqlFieldType.DATETIME2, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.DATETIME_WITH_TZ]: { sqlTypeName: SqlFieldType.DATETIMEOFFSET, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.DECIMAL]: { sqlTypeName: SqlFieldType.DECIMAL, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.FLOAT]: { sqlTypeName: SqlFieldType.FLOAT, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.DOUBLE]: { sqlTypeName: SqlFieldType.REAL, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.DATE]: { sqlTypeName: SqlFieldType.DATE, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.BOOLEAN]: { sqlTypeName: SqlFieldType.BIT, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.BIG_INTEGER]: { sqlTypeName: SqlFieldType.BIGINT, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.MULTILINE_TEXT]: { sqlTypeName: SqlFieldType.MULTILINE, fieldDisplayType: exports.FieldDisplayType.Basic },
+        [exports.EntityFieldDataType.FILE]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.File },
+        [exports.EntityFieldDataType.CHOICE_SET_SINGLE]: { sqlTypeName: SqlFieldType.INT, fieldDisplayType: exports.FieldDisplayType.ChoiceSetSingle },
+        [exports.EntityFieldDataType.CHOICE_SET_MULTIPLE]: { sqlTypeName: SqlFieldType.NVARCHAR, fieldDisplayType: exports.FieldDisplayType.ChoiceSetMultiple },
+        [exports.EntityFieldDataType.AUTO_NUMBER]: { sqlTypeName: SqlFieldType.DECIMAL, fieldDisplayType: exports.FieldDisplayType.AutoNumber },
+        [exports.EntityFieldDataType.RELATIONSHIP]: { sqlTypeName: SqlFieldType.UNIQUEIDENTIFIER, fieldDisplayType: exports.FieldDisplayType.Relationship },
+    };
+    /**
+     * Maps FieldDisplayType values to EntityFieldDataType for types that share SQL types
+     * with other field types (File, ChoiceSetSingle, ChoiceSetMultiple, AutoNumber).
+     * Used during read-side transformation to produce the correct EntityFieldDataType.
+     */
+    const FieldDisplayTypeToDataType = {
+        [exports.FieldDisplayType.File]: exports.EntityFieldDataType.FILE,
+        [exports.FieldDisplayType.ChoiceSetSingle]: exports.EntityFieldDataType.CHOICE_SET_SINGLE,
+        [exports.FieldDisplayType.ChoiceSetMultiple]: exports.EntityFieldDataType.CHOICE_SET_MULTIPLE,
+        [exports.FieldDisplayType.AutoNumber]: exports.EntityFieldDataType.AUTO_NUMBER,
+        [exports.FieldDisplayType.Relationship]: exports.EntityFieldDataType.RELATIONSHIP,
+    };
     /**
      * Maps SQL field types to friendly display names
      */
@@ -11562,7 +11654,7 @@
         [SqlFieldType.DATE]: exports.EntityFieldDataType.DATE,
         [SqlFieldType.BIT]: exports.EntityFieldDataType.BOOLEAN,
         [SqlFieldType.DECIMAL]: exports.EntityFieldDataType.DECIMAL,
-        [SqlFieldType.MULTILINE]: exports.EntityFieldDataType.MULTILINE_TEXT
+        [SqlFieldType.MULTILINE]: exports.EntityFieldDataType.MULTILINE_TEXT,
     };
 
     /**
@@ -11680,11 +11772,7 @@
                 expansionLevel: options.expansionLevel
             });
             const response = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_RECORD_BY_ID(entityId, recordId), { params });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            // Apply EntityMap transformations
-            const transformedResponse = transformData(camelResponse, EntityMap);
-            return transformedResponse;
+            return response.data;
         }
         /**
          * Inserts a single record into an entity by entity ID
@@ -11717,9 +11805,7 @@
                 params,
                 ...options
             });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Inserts data into an entity by entity ID using batch insert
@@ -11760,9 +11846,7 @@
                 params,
                 ...options
             });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Updates a single record in an entity by entity ID
@@ -11796,9 +11880,7 @@
                 params,
                 ...options
             });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Updates data in an entity by entity ID
@@ -11840,9 +11922,7 @@
                 params,
                 ...options
             });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Deletes data from an entity by entity ID
@@ -11872,9 +11952,7 @@
                 params,
                 ...options
             });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Gets all entities in the system
@@ -11906,6 +11984,99 @@
             });
             return entities;
         }
+        /**
+         * Queries entity records with filters, sorting, and pagination
+         *
+         * @param id - UUID of the entity
+         * @param options - Query options including filterGroup, selectedFields, sortOptions, and pagination
+         * @returns Promise resolving to {@link NonPaginatedResponse} without pagination options,
+         *   or {@link PaginatedResponse} when `pageSize`, `cursor`, or `jumpToPage` are provided
+         *
+         * @example
+         * ```typescript
+         * import { Entities, LogicalOperator, QueryFilterOperator } from '@uipath/uipath-typescript/entities';
+         *
+         * const entities = new Entities(sdk);
+         *
+         * // Non-paginated query with a filter
+         * const result = await entities.queryRecordsById("<entityId>", {
+         *   filterGroup: {
+         *     logicalOperator: LogicalOperator.And,
+         *     queryFilters: [
+         *       { fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }
+         *     ]
+         *   },
+         *   sortOptions: [{ fieldName: "created_at", isDescending: true }],
+         * });
+         * console.log(`Found ${result.totalCount} records`);
+         *
+         * // With pagination
+         * const page1 = await entities.queryRecordsById("<entityId>", {
+         *   filterGroup: { queryFilters: [{ fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }] },
+         *   pageSize: 25,
+         * });
+         * if (page1.hasNextPage) {
+         *   const page2 = await entities.queryRecordsById("<entityId>", { cursor: page1.nextCursor });
+         * }
+         * ```
+         */
+        async queryRecordsById(id, options) {
+            return PaginationHelpers.getAll({
+                serviceAccess: this.createPaginationServiceAccess(),
+                getEndpoint: () => DATA_FABRIC_ENDPOINTS.ENTITY.QUERY_BY_ID(id),
+                method: HTTP_METHODS.POST,
+                pagination: {
+                    paginationType: PaginationType.OFFSET,
+                    itemsField: ENTITY_PAGINATION.ITEMS_FIELD,
+                    totalCountField: ENTITY_PAGINATION.TOTAL_COUNT_FIELD,
+                    paginationParams: {
+                        pageSizeParam: ENTITY_OFFSET_PARAMS.PAGE_SIZE_PARAM,
+                        offsetParam: ENTITY_OFFSET_PARAMS.OFFSET_PARAM,
+                        countParam: ENTITY_OFFSET_PARAMS.COUNT_PARAM
+                    }
+                },
+                excludeFromPrefix: ['expansionLevel', 'filterGroup', 'selectedFields', 'sortOptions']
+            }, options);
+        }
+        /**
+         * Imports records from a CSV file into an entity
+         *
+         * @param id - UUID of the entity
+         * @param file - CSV file to import (Blob, File, or Uint8Array)
+         * @returns Promise resolving to import result with record counts
+         *
+         * @example
+         * ```typescript
+         * import { Entities } from '@uipath/uipath-typescript/entities';
+         *
+         * const entities = new Entities(sdk);
+         *
+         * // Browser: upload from file input
+         * const fileInput = document.getElementById('csv-input') as HTMLInputElement;
+         * const result = await entities.importRecordsById("<entityId>", fileInput.files[0]);
+         *
+         * // Node.js: read from disk
+         * const fileBuffer = fs.readFileSync('records.csv');
+         * const result = await entities.importRecordsById("<entityId>", new Blob([fileBuffer], { type: 'text/csv' }));
+         *
+         * console.log(`Inserted ${result.insertedRecords} of ${result.totalRecords} records`);
+         * if (result.errorFileLink) {
+         *   console.log(`Error file link: ${result.errorFileLink}`);
+         * }
+         * ```
+         * @internal
+         */
+        async importRecordsById(id, file) {
+            const formData = new FormData();
+            if (file instanceof Uint8Array) {
+                formData.append('file', new Blob([file.buffer]));
+            }
+            else {
+                formData.append('file', file);
+            }
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.BULK_UPLOAD_BY_ID(id), formData);
+            return response.data;
+        }
         /**
          * Downloads an attachment from an entity record field
          *
@@ -11926,7 +12097,7 @@
          *
          * // Get the recordId from getAllRecords()
          * const records = await entities.getAllRecords(entityId);
-         * const recordId = records[0].id;
+         * const recordId = records[0].Id;
          *
          * // Download attachment for a specific record and field
          * const blob = await entities.downloadAttachment(entityId, recordId, 'Documents');
@@ -11960,7 +12131,7 @@
          *
          * // Get the recordId from getAllRecords()
          * const records = await entities.getAllRecords(entityId);
-         * const recordId = records[0].id;
+         * const recordId = records[0].Id;
          *
          * // Upload a file attachment
          * const response = await entities.uploadAttachment(entityId, recordId, 'Documents', file);
@@ -11976,9 +12147,7 @@
             }
             const params = createParams({ expansionLevel: options?.expansionLevel });
             const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPLOAD_ATTACHMENT(entityId, recordId, fieldName), formData, { params });
-            // Convert PascalCase response to camelCase
-            const camelResponse = pascalToCamelCaseKeys(response.data);
-            return camelResponse;
+            return response.data;
         }
         /**
          * Removes an attachment from a File-type field of an entity record
@@ -12000,7 +12169,7 @@
          *
          * // Get the recordId from getAllRecords()
          * const records = await entities.getAllRecords(entityId);
-         * const recordId = records[0].id;
+         * const recordId = records[0].Id;
          *
          * // Delete attachment for a specific record and field
          * await entities.deleteAttachment(entityId, recordId, 'Documents');
@@ -12032,18 +12201,169 @@
             return this.insertRecordsById(id, data, options);
         }
         /**
-         * @hidden
-         * @deprecated Use {@link updateRecordsById} instead.
+         * Creates a new Data Fabric entity with the given schema
+         *
+         * @param name - Entity name — must start with a letter and contain
+         *   only letters, numbers, and underscores (e.g., `"productCatalog"`).
+         * @param fields - Array of field definitions
+         * @param options - Optional entity-level settings ({@link EntityCreateOptions})
+         * @returns Promise resolving to the ID of the created entity
+         *
+         * @example
+         * ```typescript
+         * const entityId = await entities.create("product_catalog", [
+         *   { 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 });
+         * ```
+         * @internal
          */
-        async updateById(id, data, options = {}) {
-            return this.updateRecordsById(id, data, options);
+        async create(name, fields, options) {
+            this.validateName(name, 'entity');
+            for (const field of fields) {
+                this.validateName(field.fieldName, 'field');
+            }
+            const opts = options ?? {};
+            const payload = {
+                ...(opts.description !== undefined && { description: opts.description }),
+                displayName: opts.displayName ?? name,
+                entityDefinition: {
+                    name,
+                    fields: fields.map(f => this.buildSchemaFieldPayload(f)),
+                    folderId: opts.folderKey ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                    isRbacEnabled: opts.isRbacEnabled ?? false,
+                    isInsightsEnabled: opts.isAnalyticsEnabled ?? false,
+                    externalFields: opts.externalFields ?? [],
+                },
+            };
+            const response = await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, payload);
+            return response.data;
         }
         /**
-         * @hidden
-         * @deprecated Use {@link deleteRecordsById} instead.
+         * Deletes a Data Fabric entity and all its records
+         *
+         * @param id - UUID of the entity to delete
+         * @returns Promise resolving when the entity is deleted
+         *
+         * @example
+         * ```typescript
+         * await entities.deleteById("<entityId>");
+         * ```
+         * @internal
          */
-        async deleteById(id, recordIds, options = {}) {
-            return this.deleteRecordsById(id, recordIds, options);
+        async deleteById(id) {
+            await this.delete(DATA_FABRIC_ENDPOINTS.ENTITY.DELETE(id));
+        }
+        /**
+         * Updates an existing Data Fabric entity — schema and/or metadata.
+         *
+         * Provide any combination of schema fields (`addFields`, `removeFields`, `updateFields`) and
+         * metadata fields (`displayName`, `description`, `isRbacEnabled`). Each group is applied
+         * only when the corresponding fields are present.
+         *
+         * **Warning:** Schema changes (`addFields`, `removeFields`, `updateFields`) use a
+         * read-modify-write pattern — concurrent calls on the same entity may silently
+         * overwrite each other's changes.
+         *
+         * @param id - UUID of the entity to update
+         * @param options - Changes to apply ({@link EntityUpdateByIdOptions})
+         * @returns Promise resolving when the update is complete
+         *
+         * @example
+         * ```typescript
+         * // Schema-only
+         * await entities.updateById("<entityId>", {
+         *   addFields: [{ fieldName: "notes", type: EntityFieldDataType.MULTILINE_TEXT }],
+         *   removeFields: [{ fieldName: "old_field" }],
+         * });
+         *
+         * // Metadata-only
+         * await entities.updateById("<entityId>", {
+         *   displayName: "My Updated Entity",
+         *   description: "Updated description",
+         * });
+         *
+         * // Combined
+         * await entities.updateById("<entityId>", {
+         *   updateFields: [{ id: "<fieldId>", displayName: "Unit Price", isRequired: true }],
+         *   displayName: "Price Catalog",
+         * });
+         * ```
+         * @internal
+         */
+        async updateById(id, options) {
+            const opts = options ?? {};
+            const hasSchemaChanges = !!(opts.addFields?.length || opts.removeFields?.length || opts.updateFields?.length);
+            const hasMetadataChanges = opts.displayName !== undefined || opts.description !== undefined || opts.isRbacEnabled !== undefined;
+            if (hasSchemaChanges) {
+                await this.applySchemaUpdate(id, opts);
+            }
+            if (hasMetadataChanges) {
+                await this.patch(DATA_FABRIC_ENDPOINTS.ENTITY.UPDATE_METADATA(id), {
+                    ...(opts.displayName !== undefined && { displayName: opts.displayName }),
+                    ...(opts.description !== undefined && { description: opts.description }),
+                    ...(opts.isRbacEnabled !== undefined && { isRbacEnabled: opts.isRbacEnabled }),
+                });
+            }
+        }
+        /**
+         * Fetches the current entity schema, applies the field delta, then posts the full updated schema.
+         *
+         * @param entityId - UUID of the entity to update
+         * @param options - Field changes to apply
+         * @private
+         */
+        async applySchemaUpdate(entityId, options) {
+            const entityResponse = await this.get(DATA_FABRIC_ENDPOINTS.ENTITY.GET_BY_ID(entityId));
+            const raw = entityResponse.data;
+            // Carry forward existing non-system fields from GET response (skip system/primary-key fields)
+            let fields = (raw.fields ?? [])
+                .filter(f => !f.isSystemField && !f.isPrimaryKey);
+            // Filter out removed fields
+            if (options.removeFields?.length) {
+                const removeSet = new Set(options.removeFields.map(r => r.fieldName));
+                fields = fields.filter(f => !removeSet.has(f.name));
+            }
+            // Apply per-field metadata updates (matched by field ID)
+            if (options.updateFields?.length) {
+                const updateMap = new Map(options.updateFields.map(u => [u.id, u]));
+                fields = fields.map(f => {
+                    const update = updateMap.get(f.id ?? '');
+                    if (!update)
+                        return f;
+                    return {
+                        ...f,
+                        ...(update.displayName !== undefined && { displayName: update.displayName }),
+                        ...(update.description !== undefined && { description: update.description }),
+                        ...(update.isRequired !== undefined && { isRequired: update.isRequired }),
+                        ...(update.isUnique !== undefined && { isUnique: update.isUnique }),
+                        ...(update.isRbacEnabled !== undefined && { isRbacEnabled: update.isRbacEnabled }),
+                        ...(update.isEncrypted !== undefined && { isEncrypted: update.isEncrypted }),
+                        ...(update.defaultValue !== undefined && { defaultValue: update.defaultValue }),
+                    };
+                });
+            }
+            // Build and append new fields
+            const newFields = [];
+            if (options.addFields?.length) {
+                for (const field of options.addFields) {
+                    this.validateName(field.fieldName, 'field');
+                }
+                newFields.push(...options.addFields.map(f => this.buildSchemaFieldPayload(f)));
+            }
+            await this.post(DATA_FABRIC_ENDPOINTS.ENTITY.UPSERT, {
+                displayName: raw.displayName,
+                description: raw.description,
+                entityDefinition: {
+                    id: entityId,
+                    name: raw.name,
+                    fields: [...fields, ...newFields],
+                    folderId: raw.folderId ?? DATA_FABRIC_TENANT_FOLDER_ID,
+                    isRbacEnabled: raw.isRbacEnabled ?? false,
+                    isInsightsEnabled: raw.isInsightsEnabled ?? false,
+                    externalFields: raw.externalFields ?? [],
+                },
+            });
         }
         /**
          * Orchestrates all field mapping transformations
@@ -12067,11 +12387,20 @@
             metadata.fields = metadata.fields.map(field => {
                 // Rename sqlType to fieldDataType
                 let transformedField = transformData(field, EntityMap);
-                // Map SQL field type to friendly name
+                // Map field type: prefer fieldDisplayType for types that share SQL types (File, ChoiceSet, AutoNumber)
                 if (transformedField.fieldDataType?.name) {
-                    const sqlTypeName = transformedField.fieldDataType.name;
-                    if (EntityFieldTypeMap[sqlTypeName]) {
-                        transformedField.fieldDataType.name = EntityFieldTypeMap[sqlTypeName];
+                    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;
+                        }
                     }
                 }
                 this.transformNestedReferences(transformedField);
@@ -12115,7 +12444,44 @@
                 return externalSource;
             });
         }
+        /** 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];
+            return {
+                name: field.fieldName,
+                displayName: field.displayName ?? field.fieldName,
+                sqlType: { name: mapping.sqlTypeName },
+                fieldDisplayType: mapping.fieldDisplayType,
+                description: field.description ?? '',
+                isRequired: field.isRequired ?? false,
+                isUnique: field.isUnique ?? false,
+                isRbacEnabled: field.isRbacEnabled ?? false,
+                isEncrypted: field.isEncrypted ?? false,
+                ...(field.defaultValue !== undefined && { defaultValue: field.defaultValue }),
+                ...(field.choiceSetId !== undefined && { choiceSetId: field.choiceSetId }),
+                ...(field.referenceEntityName !== undefined && { referenceEntityName: field.referenceEntityName }),
+                ...(field.referenceFieldName !== undefined && { referenceFieldName: field.referenceFieldName }),
+            };
+        }
+        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_]+/, '');
+                const defaultName = `My${context.charAt(0).toUpperCase() + context.slice(1)}`;
+                throw new ValidationError({
+                    message: `Invalid ${context} name '${name}'. Must start with a letter, contain only letters, numbers, and underscores, 3–100 characters (e.g., "${suggestion || defaultName}").`
+                });
+            }
+            if (context === 'field' && EntityService.RESERVED_FIELD_NAMES.has(name)) {
+                throw new ValidationError({
+                    message: `Field name '${name}' is reserved. Reserved names: ${[...EntityService.RESERVED_FIELD_NAMES].join(', ')}.`
+                });
+            }
+        }
     }
+    EntityService.RESERVED_FIELD_NAMES = new Set([
+        'Id', 'CreatedBy', 'CreateTime', 'UpdatedBy', 'UpdateTime'
+    ]);
     __decorate([
         track('Entities.GetById')
     ], EntityService.prototype, "getById", null);
@@ -12143,6 +12509,12 @@
     __decorate([
         track('Entities.GetAll')
     ], EntityService.prototype, "getAll", null);
+    __decorate([
+        track('Entities.QueryRecordsById')
+    ], EntityService.prototype, "queryRecordsById", null);
+    __decorate([
+        track('Entities.ImportRecordsById')
+    ], EntityService.prototype, "importRecordsById", null);
     __decorate([
         track('Entities.DownloadAttachment')
     ], EntityService.prototype, "downloadAttachment", null);
@@ -12152,6 +12524,15 @@
     __decorate([
         track('Entities.DeleteAttachment')
     ], EntityService.prototype, "deleteAttachment", null);
+    __decorate([
+        track('Entities.Create')
+    ], EntityService.prototype, "create", null);
+    __decorate([
+        track('Entities.DeleteById')
+    ], EntityService.prototype, "deleteById", null);
+    __decorate([
+        track('Entities.UpdateById')
+    ], EntityService.prototype, "updateById", null);
 
     class ChoiceSetService extends BaseService {
         /**
@@ -14719,6 +15100,36 @@
         BucketOptions["AccessDataThroughOrchestrator"] = "AccessDataThroughOrchestrator";
     })(exports.BucketOptions || (exports.BucketOptions = {}));
 
+    /**
+     * Creates methods for a job response object.
+     *
+     * @param jobData - The raw job data from API
+     * @param service - The job service instance
+     * @returns Object containing job methods
+     */
+    function createJobMethods(jobData, service) {
+        return {
+            async getOutput() {
+                if (!jobData.key)
+                    throw new Error('Job key is undefined');
+                if (!jobData.folderId)
+                    throw new Error('Job folderId is undefined');
+                return service.getOutput(jobData.key, jobData.folderId);
+            },
+        };
+    }
+    /**
+     * Creates a job response with bound methods.
+     *
+     * @param jobData - The raw job data from API
+     * @param service - The job service instance
+     * @returns A job object with added methods
+     */
+    function createJobWithMethods(jobData, service) {
+        const methods = createJobMethods(jobData, service);
+        return Object.assign({}, jobData, methods);
+    }
+
     /**
      * Maps fields for Job entities to ensure consistent naming
      * Semantic renames only — case conversion handled by pascalToCamelCaseKeys()
@@ -14734,27 +15145,81 @@
         release: 'process',
     };
 
+    /**
+     * Maps fields for Attachment entities to ensure consistent naming
+     */
+    const AttachmentsMap = {
+        creationTime: 'createdTime',
+        lastModificationTime: 'lastModifiedTime'
+    };
+
+    class AttachmentService extends BaseService {
+        /**
+         * Gets an attachment by ID
+         * @param id - The UUID of the attachment to retrieve
+         * @param options - Optional query parameters (expand, select)
+         * @returns Promise resolving to the attachment
+         *
+         * @example
+         * ```typescript
+         * import { Attachments } from '@uipath/uipath-typescript/attachments';
+         *
+         * const attachments = new Attachments(sdk);
+         * const attachment = await attachments.getById('12345678-1234-1234-1234-123456789abc');
+         * ```
+         */
+        async getById(id, options = {}) {
+            if (!id) {
+                throw new ValidationError({ message: 'id is required for getById' });
+            }
+            // Prefix all keys in options with $ for OData
+            const keysToPrefix = Object.keys(options);
+            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
+            const response = await this.get(ORCHESTRATOR_ATTACHMENT_ENDPOINTS.GET_BY_ID(id), {
+                params: apiOptions,
+            });
+            // Transform response from PascalCase to camelCase, then apply field maps
+            const camelCased = pascalToCamelCaseKeys(response.data);
+            camelCased.blobFileAccess = transformData(camelCased.blobFileAccess, BucketMap);
+            return transformData(camelCased, AttachmentsMap);
+        }
+    }
+    __decorate([
+        track('Attachments.GetById')
+    ], AttachmentService.prototype, "getById", null);
+
     /**
      * Service for interacting with UiPath Orchestrator Jobs API
      */
     class JobService extends FolderScopedService {
         /**
-         * Gets all jobs across folders with optional filtering
+         * Creates an instance of the Jobs service.
+         *
+         * @param instance - UiPath SDK instance providing authentication and configuration
+         */
+        constructor(instance) {
+            super(instance);
+            this.attachmentService = new AttachmentService(instance);
+        }
+        /**
+         * Gets all jobs across folders with optional filtering and pagination.
          *
-         * @param options - Query options including optional folderId and pagination options
-         * @returns Promise resolving to array of jobs or paginated response
+         * Returns jobs with full details including state, timing, and input/output arguments.
+         * Pass `folderId` to scope the query to a specific folder.
          *
+         * !!! info "Input and output fields are not included in `getAll` responses"
+         *     The `inputArguments`, `inputFile`, `outputArguments`, and `outputFile` fields will always be `null` in the `getAll` response. To retrieve a job's output, use the {@link getOutput} method with the job's `key` and `folderId`.
+         *
+         * @param options - Query options including optional folderId, filtering, and pagination options
+         * @returns Promise resolving to either an array of jobs {@link NonPaginatedResponse}<{@link JobGetResponse}> or a {@link PaginatedResponse}<{@link JobGetResponse}> when pagination options are used.
+         * {@link JobGetResponse}
          * @example
          * ```typescript
-         * import { Jobs } from '@uipath/uipath-typescript/jobs';
-         *
-         * const jobs = new Jobs(sdk);
-         *
          * // Get all jobs
          * const allJobs = await jobs.getAll();
          *
          * // Get all jobs in a specific folder
-         * const folderJobs = await jobs.getAll({ folderId: 123 });
+         * const folderJobs = await jobs.getAll({ folderId: <folderId> });
          *
          * // With filtering
          * const runningJobs = await jobs.getAll({
@@ -14768,10 +15233,19 @@
          * if (page1.hasNextPage) {
          *   const page2 = await jobs.getAll({ cursor: page1.nextCursor });
          * }
+         *
+         * // Jump to specific page
+         * const page5 = await jobs.getAll({
+         *   jumpToPage: 5,
+         *   pageSize: 10
+         * });
          * ```
          */
         async getAll(options) {
-            const transformJobResponse = (job) => transformData(pascalToCamelCaseKeys(job), JobMap);
+            const transformJobResponse = (job) => {
+                const rawJob = transformData(pascalToCamelCaseKeys(job), JobMap);
+                return createJobWithMethods(rawJob, this);
+            };
             return PaginationHelpers.getAll({
                 serviceAccess: this.createPaginationServiceAccess(),
                 getEndpoint: () => JOB_ENDPOINTS.GET_ALL,
@@ -14789,10 +15263,144 @@
                 },
             }, options);
         }
+        /**
+         * Gets a job by its unique key (GUID).
+         *
+         * Returns the full job details including state, timing, input/output arguments, and error information.
+         * Use `expand` to include related entities like `robot`, or `machine`.
+         *
+         * @param id - The unique key (GUID) of the job to retrieve
+         * @param folderId - The folder ID where the job resides
+         * @param options - Optional query options for expanding or selecting fields
+         * @returns Promise resolving to a {@link JobGetResponse} with full job details and bound methods
+         *
+         * @example
+         * ```typescript
+         * // Get a job by key
+         * const job = await jobs.getById(<id>, <folderId>);
+         * console.log(job.state, job.processName);
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // With expanded related entities
+         * const job = await jobs.getById(<id>, <folderId>, {
+         *   expand: 'robot,machine'
+         * });
+         * console.log(job.robot?.name, job.machine?.name);
+         * ```
+         */
+        async getById(id, folderId, options) {
+            if (!id) {
+                throw new ValidationError({ message: 'id is required for getById' });
+            }
+            if (!folderId) {
+                throw new ValidationError({ message: 'folderId is required for getById' });
+            }
+            const headers = createHeaders({ [FOLDER_ID]: folderId });
+            const keysToPrefix = Object.keys(options ?? {});
+            const apiOptions = options ? addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix) : {};
+            const response = await this.get(JOB_ENDPOINTS.GET_BY_KEY(id), {
+                params: apiOptions,
+                headers,
+            });
+            const rawJob = transformData(pascalToCamelCaseKeys(response.data), JobMap);
+            return createJobWithMethods(rawJob, this);
+        }
+        /**
+         * Gets the output of a completed job.
+         *
+         * Retrieves the job's output arguments, handling both inline output (stored directly on the job
+         * as a JSON string in `outputArguments`) and file-based output (stored as a blob attachment for
+         * large outputs). Returns the parsed JSON output or `null` if the job has no output.
+         *
+         * @param jobKey - The unique key (GUID) of the job to retrieve output from
+         * @param folderId - The folder ID where the job resides
+         * @returns Promise resolving to the parsed output as `Record<string, unknown>`, or `null` if no output exists
+         *
+         * @example
+         * ```typescript
+         * // Get output from a completed job
+         * const output = await jobs.getOutput(<jobKey>, <folderId>);
+         *
+         * if (output) {
+         *   console.log('Job output:', output);
+         * }
+         * ```
+         *
+         * @example
+         * ```typescript
+         * // Get output using bound method (jobKey and folderId are taken from the job object)
+         * const allJobs = await jobs.getAll();
+         * const completedJob = allJobs.items.find(j => j.state === JobState.Successful);
+         *
+         * if (completedJob) {
+         *   const output = await completedJob.getOutput();
+         * }
+         * ```
+         */
+        async getOutput(jobKey, folderId) {
+            if (!jobKey) {
+                throw new ValidationError({ message: 'jobKey is required for getOutput' });
+            }
+            const job = await this.getById(jobKey, folderId, { select: 'outputArguments,outputFile' });
+            if (job.outputArguments) {
+                try {
+                    return JSON.parse(job.outputArguments);
+                }
+                catch {
+                    throw new ServerError({ message: 'Failed to parse job output arguments as JSON' });
+                }
+            }
+            if (job.outputFile) {
+                return this.downloadOutputFile(job.outputFile);
+            }
+            return null;
+        }
+        /**
+         * Downloads the output file content via the Attachments API.
+         * 1. Fetches blob access info from the attachment using AttachmentService
+         * 2. Downloads content from the presigned blob URI
+         * 3. Parses and returns the JSON content
+         */
+        async downloadOutputFile(outputFileKey) {
+            const attachment = await this.attachmentService.getById(outputFileKey);
+            const blobAccess = attachment.blobFileAccess;
+            if (!blobAccess?.uri) {
+                return null;
+            }
+            const blobHeaders = { ...blobAccess.headers };
+            // Add auth header if the blob URI requires authenticated access
+            if (blobAccess.requiresAuth) {
+                const token = await this.getValidAuthToken();
+                blobHeaders['Authorization'] = `Bearer ${token}`;
+            }
+            const blobResponse = await fetch(blobAccess.uri, {
+                method: 'GET',
+                headers: blobHeaders,
+            });
+            if (!blobResponse.ok) {
+                const errorInfo = await errorResponseParser.parse(blobResponse);
+                throw ErrorFactory.createFromHttpStatus(blobResponse.status, errorInfo);
+            }
+            const content = await blobResponse.text();
+            try {
+                return JSON.parse(content);
+            }
+            catch {
+                throw new ServerError({ message: 'Failed to parse job output file as JSON' });
+            }
+        }
     }
     __decorate([
         track('Jobs.GetAll')
     ], JobService.prototype, "getAll", null);
+    __decorate([
+        track('Jobs.GetById')
+    ], JobService.prototype, "getById", null);
+    __decorate([
+        track('Jobs.GetOutput')
+    ], JobService.prototype, "getOutput", null);
 
     /**
      * Enum for job sub-state
@@ -14819,6 +15427,22 @@
         ServerlessJobType["PythonAgent"] = "PythonAgent";
     })(exports.ServerlessJobType || (exports.ServerlessJobType = {}));
 
+    /**
+     * Common enum for job state used across services
+     */
+    exports.JobState = void 0;
+    (function (JobState) {
+        JobState["Pending"] = "Pending";
+        JobState["Running"] = "Running";
+        JobState["Stopping"] = "Stopping";
+        JobState["Terminating"] = "Terminating";
+        JobState["Faulted"] = "Faulted";
+        JobState["Successful"] = "Successful";
+        JobState["Stopped"] = "Stopped";
+        JobState["Suspended"] = "Suspended";
+        JobState["Resumed"] = "Resumed";
+    })(exports.JobState || (exports.JobState = {}));
+
     /**
      * Maps fields for Process entities to ensure consistent naming
      */
@@ -15275,49 +15899,6 @@
         track('Queues.GetById')
     ], QueueService.prototype, "getById", null);
 
-    /**
-     * Maps fields for Attachment entities to ensure consistent naming
-     */
-    const AttachmentsMap = {
-        creationTime: 'createdTime',
-        lastModificationTime: 'lastModifiedTime'
-    };
-
-    class AttachmentService extends BaseService {
-        /**
-         * Gets an attachment by ID
-         * @param id - The UUID of the attachment to retrieve
-         * @param options - Optional query parameters (expand, select)
-         * @returns Promise resolving to the attachment
-         *
-         * @example
-         * ```typescript
-         * import { Attachments } from '@uipath/uipath-typescript/attachments';
-         *
-         * const attachments = new Attachments(sdk);
-         * const attachment = await attachments.getById('12345678-1234-1234-1234-123456789abc');
-         * ```
-         */
-        async getById(id, options = {}) {
-            if (!id) {
-                throw new ValidationError({ message: 'id is required for getById' });
-            }
-            // Prefix all keys in options with $ for OData
-            const keysToPrefix = Object.keys(options);
-            const apiOptions = addPrefixToKeys(options, ODATA_PREFIX, keysToPrefix);
-            const response = await this.get(ORCHESTRATOR_ATTACHMENT_ENDPOINTS.GET_BY_ID(id), {
-                params: apiOptions,
-            });
-            // Transform response from PascalCase to camelCase, then apply field maps
-            const camelCased = pascalToCamelCaseKeys(response.data);
-            camelCased.blobFileAccess = transformData(camelCased.blobFileAccess, BucketMap);
-            return transformData(camelCased, AttachmentsMap);
-        }
-    }
-    __decorate([
-        track('Attachments.GetById')
-    ], AttachmentService.prototype, "getById", null);
-
     /**
      * UiPath SDK - Legacy class providing all services through property getters.
      *
@@ -15433,22 +16014,6 @@
         }
     }
 
-    /**
-     * Common enum for job state used across services
-     */
-    exports.JobState = void 0;
-    (function (JobState) {
-        JobState["Pending"] = "Pending";
-        JobState["Running"] = "Running";
-        JobState["Stopping"] = "Stopping";
-        JobState["Terminating"] = "Terminating";
-        JobState["Faulted"] = "Faulted";
-        JobState["Successful"] = "Successful";
-        JobState["Stopped"] = "Stopped";
-        JobState["Suspended"] = "Suspended";
-        JobState["Resumed"] = "Resumed";
-    })(exports.JobState || (exports.JobState = {}));
-
     /**
      * Common Constants for Conversational Agent
      */
@@ -15821,6 +16386,7 @@
     exports.createCaseInstanceWithMethods = createCaseInstanceWithMethods;
     exports.createConversationWithMethods = createConversationWithMethods;
     exports.createEntityWithMethods = createEntityWithMethods;
+    exports.createJobWithMethods = createJobWithMethods;
     exports.createProcessInstanceWithMethods = createProcessInstanceWithMethods;
     exports.createProcessWithMethods = createProcessWithMethods;
     exports.createTaskWithMethods = createTaskWithMethods;