@uipath/uipath-typescript 1.3.0 → 1.3.2

package/dist/entities/index.d.ts

@@ -227,6 +227,8 @@ declare class BaseService {
      *
      * @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
@@ -246,7 +248,7 @@ declare class BaseService {
      * const entities = new Entities(sdk);
      * ```
      */
-    constructor(instance: IUiPath);
+    constructor(instance: IUiPath, headers?: Record<string, string>);
     /**
      * Gets a valid authentication token, refreshing if necessary.
      * Use this when you need to manually add Authorization headers (e.g., direct uploads).
@@ -290,7 +292,7 @@ declare class BaseService {
 }
 
 /**
- * Entity field type names
+ * Entity field data type names (SQL-level types returned by the API)
  */
 declare enum EntityFieldDataType {
     UUID = "UUID",
@@ -304,7 +306,12 @@ declare enum EntityFieldDataType {
     DATE = "DATE",
     BOOLEAN = "BOOLEAN",
     BIG_INTEGER = "BIG_INTEGER",
-    MULTILINE_TEXT = "MULTILINE_TEXT"
+    MULTILINE_TEXT = "MULTILINE_TEXT",
+    FILE = "FILE",
+    CHOICE_SET_SINGLE = "CHOICE_SET_SINGLE",
+    CHOICE_SET_MULTIPLE = "CHOICE_SET_MULTIPLE",
+    AUTO_NUMBER = "AUTO_NUMBER",
+    RELATIONSHIP = "RELATIONSHIP"
 }
 /**
  * Represents a single entity record
@@ -400,6 +407,196 @@ interface EntityDeleteOptions {
  */
 interface EntityDeleteRecordsOptions extends EntityDeleteOptions {
 }
+/**
+ * Logical operator for combining query filter groups
+ */
+declare enum LogicalOperator {
+    /** Combine conditions with AND — all conditions must match */
+    And = 0,
+    /** Combine conditions with OR — any condition must match */
+    Or = 1
+}
+/**
+ * Comparison operators for entity query filters.
+ * Not all operators are valid for all field types.
+ */
+declare enum QueryFilterOperator {
+    Equals = "=",
+    NotEquals = "!=",
+    GreaterThan = ">",
+    LessThan = "<",
+    GreaterThanOrEqual = ">=",
+    LessThanOrEqual = "<=",
+    Contains = "contains",
+    NotContains = "not contains",
+    StartsWith = "startswith",
+    EndsWith = "endswith",
+    In = "in",
+    NotIn = "not in"
+}
+/**
+ * A single filter condition for querying entity records
+ *
+ * Values are always strings. For numeric or boolean fields, pass the string representation
+ * (e.g., `"42"`, `"true"`). For `In` / `NotIn` operators, use {@link valueList} instead of `value`.
+ */
+interface EntityQueryFilter {
+    /** Name of the field to filter on */
+    fieldName: string;
+    /** Comparison operator */
+    operator: QueryFilterOperator;
+    /** Value to compare against (always a string; omit when using `valueList`) */
+    value?: string;
+    /** List of values for `in` / `not in` operators */
+    valueList?: string[];
+}
+/**
+ * A group of query filters combined with a logical operator
+ */
+interface EntityQueryFilterGroup {
+    /** Logical operator applied between filters in `queryFilters` (default: AND) */
+    logicalOperator?: LogicalOperator;
+    /** Logical operator applied between sibling filter groups (default: AND) */
+    continueLogicalOperator?: LogicalOperator;
+    /** Array of filter conditions */
+    queryFilters?: EntityQueryFilter[];
+    /** Nested filter groups for complex boolean expressions */
+    filterGroups?: EntityQueryFilterGroup[];
+}
+/**
+ * Sort option for query results
+ */
+interface EntityQuerySortOption {
+    /** Name of the field to sort by */
+    fieldName: string;
+    /** Whether to sort in descending order (default: false) */
+    isDescending?: boolean;
+}
+/**
+ * Options for querying entity records with filters, sorting, and pagination.
+ *
+ * Use `pageSize`, `cursor`, or `jumpToPage` for SDK-managed pagination.
+ * The SDK computes and manages offset parameters automatically.
+ */
+type EntityQueryRecordsOptions = {
+    /** Filter conditions to apply */
+    filterGroup?: EntityQueryFilterGroup;
+    /** List of field names to include in results (returns all fields if omitted) */
+    selectedFields?: string[];
+    /** Sort options for the results */
+    sortOptions?: EntityQuerySortOption[];
+    /** Level of entity expansion for related fields (default: 0) */
+    expansionLevel?: number;
+} & PaginationOptions;
+/**
+ * Response from querying entity records
+ */
+interface EntityQueryRecordsResponse {
+    /** Array of matching entity records */
+    items: EntityRecord[];
+    /** Total number of records matching the filter (before pagination) */
+    totalCount: number;
+}
+/**
+ * Common field properties shared across field definition and update types
+ */
+interface EntityFieldBase {
+    /** Human-readable display name shown in the UI (defaults to `name` if omitted) */
+    displayName?: string;
+    /** Optional field description */
+    description?: string;
+    /** Whether the field is required (default: false) */
+    isRequired?: boolean;
+    /** Whether the field value must be unique across records (default: false) */
+    isUnique?: boolean;
+    /** Whether role-based access control is enabled for this field (default: false) */
+    isRbacEnabled?: boolean;
+    /** Whether the field value is encrypted at rest (default: false) */
+    isEncrypted?: boolean;
+    /** Default value for the field */
+    defaultValue?: string;
+}
+/**
+ * User-facing field definition for creating or updating entity schemas
+ */
+interface EntityCreateFieldOptions extends EntityFieldBase {
+    /**
+     * Field name — must start with a letter and contain only
+     * letters, numbers, and underscores (e.g., `"productName"`).
+     */
+    fieldName: string;
+    /** Field data type — one of the {@link EntityFieldDataType} values (default: STRING) */
+    type?: EntityFieldDataType;
+    /** Choice set ID for choice-set fields */
+    choiceSetId?: string;
+    /** Name of the referenced entity for relationship fields */
+    referenceEntityName?: string;
+    /** Name of the field in the referenced entity */
+    referenceFieldName?: string;
+}
+/**
+ * Options for creating a new Data Fabric entity
+ */
+interface EntityCreateOptions {
+    /** Human-readable display name shown in the UI (defaults to `name` if omitted) */
+    displayName?: string;
+    /** Optional entity description */
+    description?: string;
+    /** UUID of the folder to place the entity in (defaults to the tenant-level folder) */
+    folderKey?: string;
+    /** Whether role-based access control is enabled for this entity (default: false) */
+    isRbacEnabled?: boolean;
+    /** Whether Analytics integration is enabled for this entity (default: false) */
+    isAnalyticsEnabled?: boolean;
+    /** External field source definitions (default: empty) */
+    externalFields?: ExternalField[];
+}
+/**
+ * Identifies a field by its ID and supplies metadata updates to apply
+ */
+interface EntityFieldUpdateOptions extends EntityFieldBase {
+    /** ID of the field to update */
+    id: string;
+}
+/**
+ * Identifies a field to remove by its name
+ */
+interface EntityRemoveFieldOptions {
+    /** Name of the field to remove */
+    fieldName: string;
+}
+/**
+ * Options for updating an existing entity — schema and/or metadata in a single call.
+ *
+ * Schema changes (`addFields`, `removeFields`, `updateFields`) and metadata changes
+ * (`displayName`, `description`, `isRbacEnabled`) can be combined; each is applied
+ * only when the corresponding fields are provided.
+ */
+interface EntityUpdateByIdOptions {
+    /** New fields to add */
+    addFields?: EntityCreateFieldOptions[];
+    /** Fields to remove, each identified by field name */
+    removeFields?: EntityRemoveFieldOptions[];
+    /** Fields to update, each identified by its field ID */
+    updateFields?: EntityFieldUpdateOptions[];
+    /** New display name for the entity */
+    displayName?: string;
+    /** New description for the entity */
+    description?: string;
+    /** Whether role-based access control is enabled for this entity */
+    isRbacEnabled?: boolean;
+}
+/**
+ * Response from a bulk import operation
+ */
+interface EntityImportRecordsResponse {
+    /** Total number of records in the import file */
+    totalRecords: number;
+    /** Number of records successfully inserted */
+    insertedRecords: number;
+    /** Link to download the error file (if any records failed) */
+    errorFileLink?: string | null;
+}
 /**
  * Supported file types for attachment upload
  */
@@ -520,6 +717,17 @@ interface Field {
     id: string;
     definition?: FieldMetaData;
 }
+/**
+ * SQL type metadata
+ */
+interface SqlType {
+    /** Raw SQL type name (e.g., `"NVARCHAR"`, `"INT"`, `"UNIQUEIDENTIFIER"`) */
+    name: string;
+    lengthLimit?: number;
+    maxValue?: number;
+    minValue?: number;
+    decimalPrecision?: number;
+}
 /**
  * Detailed field definition
  */
@@ -531,25 +739,33 @@ interface FieldMetaData {
     isExternalField: boolean;
     isHiddenField: boolean;
     isUnique: boolean;
-    referenceName?: string;
-    referenceEntity?: RawEntityGetResponse;
-    referenceChoiceSet?: RawEntityGetResponse;
-    referenceField?: Field;
-    referenceType: ReferenceType;
-    fieldDataType: FieldDataType;
     isRequired: boolean;
-    displayName: string;
-    description: string;
+    isSystemField: boolean;
+    isAttachment: boolean;
+    isEncrypted: boolean;
+    isRbacEnabled: boolean;
+    fieldDisplayType: FieldDisplayType;
+    /** Transformed field data type — present after SDK transformation */
+    fieldDataType: FieldDataType;
     createdTime: string;
     createdBy: string;
-    updatedTime: string;
+    /** Raw SQL type from API — present on raw GET responses, used on write payloads */
+    sqlType?: SqlType;
+    updatedTime?: string;
     updatedBy?: string;
-    isSystemField: boolean;
-    fieldDisplayType?: FieldDisplayType;
+    displayName?: string;
+    description?: string;
+    referenceName?: string;
+    referenceEntity?: RawEntityGetResponse;
+    referenceChoiceSet?: RawEntityGetResponse;
+    referenceField?: Field;
+    referenceType?: ReferenceType;
     choiceSetId?: string;
     defaultValue?: string;
-    isAttachment: boolean;
-    isRbacEnabled: boolean;
+    /** Name of the referenced entity (used on write payloads for relationship fields) */
+    referenceEntityName?: string;
+    /** Name of the field in the referenced entity (used on write payloads for relationship fields) */
+    referenceFieldName?: string;
 }
 /**
  * External object details
@@ -620,8 +836,9 @@ interface RawEntityGetResponse {
     name: string;
     displayName: string;
     entityType: EntityType;
-    description: string;
+    description?: string;
     fields: FieldMetaData[];
+    folderId?: string;
     externalFields?: ExternalSourceFields[];
     sourceJoinCriterias?: SourceJoinCriteria[];
     recordCount?: number;
@@ -629,6 +846,7 @@ interface RawEntityGetResponse {
     usedStorageSizeInMB?: number;
     attachmentSizeInByte?: number;
     isRbacEnabled: boolean;
+    isInsightsEnabled?: boolean;
     id: string;
     createdBy: string;
     createdTime: string;
@@ -703,7 +921,7 @@ interface EntityServiceModel {
      * const choicesets = new ChoiceSets(sdk);
      *
      * // Get entity metadata with methods
-     * const entity = await entities.getById(<entityId>);
+     * const entity = await entities.getById("<entityId>");
      *
      * // Call operations directly on the entity
      * const records = await entity.getAllRecords();
@@ -735,7 +953,7 @@ interface EntityServiceModel {
      * @example
      * ```typescript
      * // Basic usage (non-paginated)
-     * const records = await entities.getAllRecords(<entityId>);
+     * const records = await entities.getAllRecords("<entityId>");
      *
      * // With expansion level
      * const records = await entities.getAllRecords(<entityId>, {
@@ -772,7 +990,7 @@ interface EntityServiceModel {
      * @example
      * ```typescript
      * // First, get records to obtain the record ID
-     * const records = await entities.getAllRecords(<entityId>);
+     * const records = await entities.getAllRecords("<entityId>");
      * // Get the recordId for the record
      * const recordId = records.items[0].Id;
      * // Get the record
@@ -901,11 +1119,6 @@ interface EntityServiceModel {
      * ```
      */
     updateRecordsById(id: string, data: EntityRecord[], options?: EntityUpdateRecordsOptions): Promise<EntityUpdateResponse>;
-    /**
-     * @deprecated Use {@link updateRecordsById} instead.
-     * @hidden
-     */
-    updateById(id: string, data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
     /**
      * Deletes data from an entity by entity ID
      *
@@ -924,10 +1137,52 @@ interface EntityServiceModel {
      */
     deleteRecordsById(id: string, recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
     /**
-     * @deprecated Use {@link deleteRecordsById} instead.
-     * @hidden
+     * Queries entity records with filters, sorting, and SDK-managed 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(<id>, {
+     *   filterGroup: {
+     *     logicalOperator: LogicalOperator.And,
+     *     queryFilters: [{ fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }]
+     *   },
+     *   sortOptions: [{ fieldName: "createdTime", isDescending: true }],
+     * });
+     * console.log(`Found ${result.totalCount} records`);
+     *
+     * // With pagination
+     * const page1 = await entities.queryRecordsById(<id>, { pageSize: 25 });
+     * if (page1.hasNextPage) {
+     *   const page2 = await entities.queryRecordsById(<id>, { cursor: page1.nextCursor });
+     * }
+     * ```
      */
-    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    queryRecordsById<T extends EntityQueryRecordsOptions = EntityQueryRecordsOptions>(id: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Imports records from a CSV file into an entity
+     *
+     * @param id - UUID of the entity
+     * @param file - CSV file to import as a Blob or File or Uint8Array
+     * @returns Promise resolving to {@link EntityImportRecordsResponse} with record counts
+     * @example
+     * ```typescript
+     * // Browser: upload from file input
+     * const fileInput = document.getElementById('csv-input') as HTMLInputElement;
+     * const result = await entities.importRecordsById(<id>, fileInput.files[0]);
+     * console.log(`Inserted ${result.insertedRecords} of ${result.totalRecords} records`);
+     * ```
+     * @internal
+     */
+    importRecordsById(id: string, file: EntityFileType): Promise<EntityImportRecordsResponse>;
     /**
      * Downloads an attachment stored in a File-type field of an entity record.
      *
@@ -1048,6 +1303,75 @@ interface EntityServiceModel {
      * ```
      */
     deleteAttachment(entityId: string, recordId: string, fieldName: string): Promise<EntityDeleteAttachmentResponse>;
+    /**
+     * Creates a new Data Fabric entity with the given schema
+     *
+     * @param name - Entity name — must start with a letter, letters/numbers/underscores only
+     *   (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
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * const id = 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
+     */
+    create(name: string, fields: EntityCreateFieldOptions[], options?: EntityCreateOptions): Promise<string>;
+    /**
+     * 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(<id>);
+     * ```
+     * @internal
+     */
+    deleteById(id: string): Promise<void>;
+    /**
+     * Updates an existing Data Fabric entity — schema and/or metadata.
+     *
+     * Pass any combination of schema fields (`addFields`, `removeFields`, `updateFields`) and
+     * metadata fields (`displayName`, `description`, `isRbacEnabled`). Each group is applied
+     * only when the corresponding fields are provided.
+     *
+     * @param id - UUID of the entity to update
+     * @param name - name of the entity (required by the API)
+     * @param options - Changes to apply ({@link EntityUpdateByIdOptions})
+     * @returns Promise resolving when the update is complete
+     *
+     * @example
+     * ```typescript
+     * // Schema-only: add a field and remove another
+     * await entities.updateById(<id>, {
+     *   addFields: [{ fieldName: "notes", type: EntityFieldDataType.MULTILINE_TEXT }],
+     *   removeFields: [{ fieldName: "old_field" }],
+     * });
+     *
+     * // Metadata-only: rename the entity
+     * await entities.updateById(<id>, {
+     *   displayName: "My Updated Entity",
+     *   description: "Updated description",
+     * });
+     *
+     * // Combined: update a field and rename at the same time
+     * await entities.updateById(<id>, {
+     *   updateFields: [{ id: <fieldId>, displayName: "Unit Price", isRequired: true }],
+     *   displayName: "Price Catalog",
+     * });
+     * ```
+     * @internal
+     */
+    updateById(id: string, options?: EntityUpdateByIdOptions): Promise<void>;
 }
 /**
  * Entity methods interface - defines operations that can be performed on an entity
@@ -1159,29 +1483,81 @@ interface EntityMethods {
      */
     batchInsert(data: Record<string, any>[], options?: EntityBatchInsertOptions): Promise<EntityBatchInsertResponse>;
     /**
-   * @deprecated Use {@link updateRecords} instead.
-   * @hidden
-   */
-    update(data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+     * Queries records in this entity with filters, sorting, and SDK-managed pagination
+     *
+     * @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
+     * const entity = await entities.getById(<entityId>);
+     * const result = await entity.queryRecords({
+     *   filterGroup: {
+     *     logicalOperator: LogicalOperator.And,
+     *     queryFilters: [{ fieldName: "status", operator: QueryFilterOperator.Equals, value: "active" }]
+     *   },
+     *   sortOptions: [{ fieldName: "createdTime", isDescending: true }],
+     * });
+     * console.log(`Found ${result.totalCount} records`);
+     * ```
+     */
+    queryRecords<T extends EntityQueryRecordsOptions = EntityQueryRecordsOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
     /**
-     * @deprecated Use {@link deleteRecords} instead.
-     * @hidden
+     * Imports records from a CSV file into this entity
+     *
+     * @param file - CSV file to import as a Blob, File, or Uint8Array
+     * @returns Promise resolving to {@link EntityImportRecordsResponse} with record counts
+     * @example
+     * ```typescript
+     * const entity = await entities.getById(<entityId>);
+     * const fileInput = document.getElementById('csv-input') as HTMLInputElement;
+     * const result = await entity.importRecords(fileInput.files[0]);
+     * console.log(`Inserted ${result.insertedRecords} of ${result.totalRecords} records`);
+     * ```
      */
-    delete(recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    importRecords(file: EntityFileType): Promise<EntityImportRecordsResponse>;
     /**
      * @deprecated Use {@link getAllRecords} instead.
      * @hidden
      */
     getRecords<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Deletes this entity and all its records
+     *
+     * @returns Promise resolving when the entity is deleted
+     * @example
+     * ```typescript
+     * const entity = await entities.getById(<id>);
+     * await entity.delete();
+     * ```
+     * @internal
+     */
+    delete(): Promise<void>;
+    /**
+     * Updates this entity — schema and/or metadata.
+     *
+     * @param options - Changes to apply ({@link EntityUpdateByIdOptions})
+     * @returns Promise resolving when the update is complete
+     * @example
+     * ```typescript
+     * const entity = await entities.getById(<id>);
+     * await entity.update({
+     *   displayName: "Updated Name",
+     *   addFields: [{ fieldName: "notes", type: EntityFieldDataType.MULTILINE_TEXT }],
+     * });
+     * ```
+     * @internal
+     */
+    update(options?: EntityUpdateByIdOptions): Promise<void>;
 }
 /**
  * Entity with methods combining metadata with operation methods
  */
 type EntityGetResponse = RawEntityGetResponse & EntityMethods;
 /**
- * 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
  */
@@ -1425,6 +1801,72 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      * ```
      */
     getAll(): Promise<EntityGetResponse[]>;
+    /**
+     * 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 });
+     * }
+     * ```
+     */
+    queryRecordsById<T extends EntityQueryRecordsOptions = EntityQueryRecordsOptions>(id: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * 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
+     */
+    importRecordsById(id: string, file: EntityFileType): Promise<EntityImportRecordsResponse>;
     /**
      * Downloads an attachment from an entity record field
      *
@@ -1524,15 +1966,83 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      */
     batchInsertById(id: string, data: Record<string, any>[], options?: EntityBatchInsertOptions): Promise<EntityBatchInsertResponse>;
     /**
-     * @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
      */
-    updateById(id: string, data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    create(name: string, fields: EntityCreateFieldOptions[], options?: EntityCreateOptions): Promise<string>;
     /**
-     * @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
+     */
+    deleteById(id: string): Promise<void>;
+    /**
+     * 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
+     */
+    updateById(id: string, options?: EntityUpdateByIdOptions): Promise<void>;
+    /**
+     * 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
      */
-    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    private applySchemaUpdate;
     /**
      * Orchestrates all field mapping transformations
      *
@@ -1558,6 +2068,10 @@ declare class EntityService extends BaseService implements EntityServiceModel {
      * @private
      */
     private mapExternalFields;
+    /** Converts a user-facing EntityCreateFieldOptions to the raw API field payload */
+    private buildSchemaFieldPayload;
+    private static readonly RESERVED_FIELD_NAMES;
+    private validateName;
 }
 
 /**
@@ -1758,5 +2272,5 @@ declare class ChoiceSetService extends BaseService implements ChoiceSetServiceMo
     getById<T extends ChoiceSetGetByIdOptions = ChoiceSetGetByIdOptions>(choiceSetId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ChoiceSetGetResponse> : NonPaginatedResponse<ChoiceSetGetResponse>>;
 }
 
-export { ChoiceSetService, ChoiceSetService as ChoiceSets, DataDirectionType, EntityService as Entities, EntityFieldDataType, EntityService, EntityType, FieldDisplayType, JoinType, ReferenceType, createEntityWithMethods };
-export type { ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityDeleteAttachmentResponse, EntityDeleteOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityFileType, EntityGetAllRecordsOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateRecordOptions, EntityUpdateRecordResponse, EntityUpdateRecordsOptions, EntityUpdateResponse, EntityUploadAttachmentOptions, EntityUploadAttachmentResponse, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, RawEntityGetResponse, SourceJoinCriteria };
+export { ChoiceSetService, ChoiceSetService as ChoiceSets, DataDirectionType, EntityService as Entities, EntityFieldDataType, EntityService, EntityType, FieldDisplayType, JoinType, LogicalOperator, QueryFilterOperator, ReferenceType, createEntityWithMethods };
+export type { ChoiceSetGetAllResponse, ChoiceSetGetByIdOptions, ChoiceSetGetResponse, ChoiceSetServiceModel, EntityBatchInsertOptions, EntityBatchInsertResponse, EntityCreateFieldOptions, EntityCreateOptions, EntityDeleteAttachmentResponse, EntityDeleteOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityFieldBase, EntityFieldUpdateOptions, EntityFileType, EntityGetAllRecordsOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityImportRecordsResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityQueryFilter, EntityQueryFilterGroup, EntityQueryRecordsOptions, EntityQueryRecordsResponse, EntityQuerySortOption, EntityRecord, EntityRemoveFieldOptions, EntityServiceModel, EntityUpdateByIdOptions, EntityUpdateOptions, EntityUpdateRecordOptions, EntityUpdateRecordResponse, EntityUpdateRecordsOptions, EntityUpdateResponse, EntityUploadAttachmentOptions, EntityUploadAttachmentResponse, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, RawEntityGetResponse, SourceJoinCriteria, SqlType };