@uipath/uipath-typescript 1.0.0-beta.18 → 1.1.0

package/dist/entities/index.d.ts

@@ -0,0 +1,1513 @@
+import { IUiPath } from '../core/index';
+
+/**
+ * Simplified universal pagination cursor
+ * Used to fetch next/previous pages
+ */
+interface PaginationCursor {
+    /** Opaque string containing all information needed to fetch next page */
+    value: string;
+}
+/**
+ * Discriminated union for pagination methods - ensures cursor and jumpToPage are mutually exclusive
+ */
+type PaginationMethodUnion = {
+    cursor?: PaginationCursor;
+    jumpToPage?: never;
+} | {
+    cursor?: never;
+    jumpToPage?: number;
+} | {
+    cursor?: never;
+    jumpToPage?: never;
+};
+/**
+ * Pagination options. Users cannot specify both cursor and jumpToPage.
+ */
+type PaginationOptions = {
+    /** Size of the page to fetch (items per page) */
+    pageSize?: number;
+} & PaginationMethodUnion;
+/**
+ * Paginated response containing items and navigation information
+ */
+interface PaginatedResponse<T> {
+    /** The items in the current page */
+    items: T[];
+    /** Total count of items across all pages (if available) */
+    totalCount?: number;
+    /** Whether more pages are available */
+    hasNextPage: boolean;
+    /** Cursor to fetch the next page (if available) */
+    nextCursor?: PaginationCursor;
+    /** Cursor to fetch the previous page (if available) */
+    previousCursor?: PaginationCursor;
+    /** Current page number (1-based, if available) */
+    currentPage?: number;
+    /** Total number of pages (if available) */
+    totalPages?: number;
+    /** Whether this pagination type supports jumping to arbitrary pages */
+    supportsPageJump: boolean;
+}
+/**
+ * Response for non-paginated calls that includes both data and total count
+ */
+interface NonPaginatedResponse<T> {
+    items: T[];
+    totalCount?: number;
+}
+/**
+ * Helper type for defining paginated method overloads
+ * Creates a union type of all ways pagination can be triggered
+ */
+type HasPaginationOptions<T> = (T & {
+    pageSize: number;
+}) | (T & {
+    cursor: PaginationCursor;
+}) | (T & {
+    jumpToPage: number;
+});
+
+/**
+ * Pagination types supported by the SDK
+ */
+declare enum PaginationType {
+    OFFSET = "offset",
+    TOKEN = "token"
+}
+/**
+ * Interface for service access methods needed by pagination helpers
+ */
+interface PaginationServiceAccess {
+    get<T>(path: string, options?: any): Promise<{
+        data: T;
+    }>;
+    post<T>(path: string, body?: any, options?: any): Promise<{
+        data: T;
+    }>;
+    requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+}
+/**
+ * Field names for extracting data from paginated responses.
+ */
+interface PaginationFieldNames {
+    itemsField?: string;
+    totalCountField?: string;
+    continuationTokenField?: string;
+}
+/**
+ * Options for the requestWithPagination method in BaseService.
+ */
+interface RequestWithPaginationOptions extends RequestSpec {
+    pagination: PaginationFieldNames & {
+        paginationType: PaginationType;
+        paginationParams?: {
+            pageSizeParam?: string;
+            offsetParam?: string;
+            tokenParam?: string;
+            countParam?: string;
+        };
+    };
+}
+
+/**
+ * HTTP methods supported by the API client
+ */
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+/**
+ * Supported response types for API requests
+ */
+type ResponseType = 'json' | 'text' | 'blob' | 'arraybuffer' | 'stream';
+/**
+ * Query parameters type with support for arrays and nested objects
+ */
+type QueryParams = Record<string, string | number | boolean | Array<string | number | boolean> | null | undefined>;
+/**
+ * Standard HTTP headers type
+ */
+type Headers = Record<string, string>;
+/**
+ * Options for request retries
+ */
+interface RetryOptions {
+    /** Maximum number of retry attempts */
+    maxRetries?: number;
+    /** Base delay between retries in milliseconds */
+    retryDelay?: number;
+    /** Whether to use exponential backoff */
+    useExponentialBackoff?: boolean;
+    /** Status codes that should trigger a retry */
+    retryableStatusCodes?: number[];
+}
+/**
+ * Options for request timeouts
+ */
+interface TimeoutOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Whether to abort the request on timeout */
+    abortOnTimeout?: boolean;
+}
+/**
+ * Options for request body transformation
+ */
+interface BodyOptions {
+    /** Whether to stringify the body */
+    stringify?: boolean;
+    /** Content type override */
+    contentType?: string;
+}
+/**
+ * Pagination metadata for API requests
+ */
+interface PaginationMetadata {
+    /** Type of pagination used by the API endpoint */
+    paginationType: PaginationType;
+    /** Response field containing items array (defaults to 'value') */
+    itemsField?: string;
+    /** Response field containing total count (defaults to '@odata.count') */
+    totalCountField?: string;
+    /** Response field containing continuation token (defaults to 'continuationToken') */
+    continuationTokenField?: string;
+}
+/**
+ * Base interface for all API requests
+ */
+interface RequestSpec {
+    /** HTTP method for the request */
+    method?: HttpMethod;
+    /** URL endpoint for the request */
+    url?: string;
+    /** Query parameters to be appended to the URL */
+    params?: QueryParams;
+    /** HTTP headers to include with the request */
+    headers?: Headers;
+    /** Raw body content (takes precedence over data) */
+    body?: unknown;
+    /** Expected response type */
+    responseType?: ResponseType;
+    /** Request timeout options */
+    timeoutOptions?: TimeoutOptions;
+    /** Retry behavior options */
+    retryOptions?: RetryOptions;
+    /** Body transformation options */
+    bodyOptions?: BodyOptions;
+    /** AbortSignal for cancelling the request */
+    signal?: AbortSignal;
+    /** Pagination metadata for the request */
+    pagination?: PaginationMetadata;
+}
+
+interface ApiResponse<T> {
+    data: T;
+}
+/**
+ * Base class for all UiPath SDK services.
+ *
+ * Provides common functionality for authentication, configuration, and API communication.
+ * All service classes extend this base to inherit dependency injection and HTTP client access.
+ *
+ * This class implements the dependency injection pattern where services receive a configured
+ * UiPath instance. The ApiClient is created internally and handles all HTTP operations
+ * including authentication token management.
+ *
+ * @remarks
+ * Service classes should extend this base and call `super(uiPath)` in their constructor.
+ * Protected HTTP methods (get, post, put, patch, delete) are available to all subclasses.
+ *
+ */
+declare class BaseService {
+    #private;
+    /**
+     * Creates a base service instance with dependency injection.
+     *
+     * Extracts configuration, execution context, and token manager from the UiPath instance
+     * to initialize an authenticated API client. The ApiClient handles all HTTP operations
+     * and token management internally.
+     *
+     * @param instance - UiPath SDK instance providing authentication and configuration.
+     *                    Services receive this via dependency injection in the modular pattern.
+     *
+     * @example
+     * ```typescript
+     * // Services automatically call this via super()
+     * export class EntityService extends BaseService {
+     *   constructor(instance: IUiPath) {
+     *     super(instance); // Initializes the internal ApiClient
+     *   }
+     * }
+     *
+     * // Usage in modular pattern
+     * import { UiPath } from '@uipath/uipath-typescript/core';
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const sdk = new UiPath(config);
+     * await sdk.initialize();
+     * const entities = new Entities(sdk);
+     * ```
+     */
+    constructor(instance: IUiPath);
+    /**
+     * Gets a valid authentication token, refreshing if necessary.
+     * Use this when you need to manually add Authorization headers (e.g., direct uploads).
+     *
+     * @returns Promise resolving to a valid access token string
+     * @throws AuthenticationError if no token is available or refresh fails
+     */
+    protected getValidAuthToken(): Promise<string>;
+    /**
+     * Creates a service accessor for pagination helpers
+     * This allows pagination helpers to access protected methods without making them public
+     */
+    protected createPaginationServiceAccess(): PaginationServiceAccess;
+    protected request<T>(method: string, path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected requestWithSpec<T>(spec: RequestSpec): Promise<ApiResponse<T>>;
+    protected get<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected post<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected put<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected patch<T>(path: string, data?: unknown, options?: RequestSpec): Promise<ApiResponse<T>>;
+    protected delete<T>(path: string, options?: RequestSpec): Promise<ApiResponse<T>>;
+    /**
+     * Execute a request with cursor-based pagination
+     */
+    protected requestWithPagination<T>(method: string, path: string, paginationOptions: PaginationOptions, options: RequestWithPaginationOptions): Promise<PaginatedResponse<T>>;
+    /**
+     * Validates and prepares pagination parameters from options
+     */
+    private validateAndPreparePaginationParams;
+    /**
+     * Prepares request parameters for pagination based on pagination type
+     */
+    private preparePaginationRequestParams;
+    /**
+     * Creates a paginated response from API response
+     */
+    private createPaginatedResponseFromResponse;
+    /**
+     * Determines if there are more pages based on pagination type and metadata
+     */
+    private determineHasMorePages;
+}
+
+/**
+ * Entity field type names
+ */
+declare enum EntityFieldDataType {
+    UUID = "UUID",
+    STRING = "STRING",
+    INTEGER = "INTEGER",
+    DATETIME = "DATETIME",
+    DATETIME_WITH_TZ = "DATETIME_WITH_TZ",
+    DECIMAL = "DECIMAL",
+    FLOAT = "FLOAT",
+    DOUBLE = "DOUBLE",
+    DATE = "DATE",
+    BOOLEAN = "BOOLEAN",
+    BIG_INTEGER = "BIG_INTEGER",
+    MULTILINE_TEXT = "MULTILINE_TEXT"
+}
+/**
+ * Represents a single entity record
+ */
+interface EntityRecord {
+    /**
+     * Unique identifier for the record
+     */
+    id: string;
+    /**
+     * Additional dynamic fields for the entity
+     */
+    [key: string]: any;
+}
+/**
+ * Options for getting an entity by Id
+ * @deprecated Use {@link EntityGetRecordByIdOptions} instead for better clarity on getting all records of an entity. This type will be removed in future versions.
+ */
+type EntityGetRecordsByIdOptions = {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+} & PaginationOptions;
+/**
+ * Options for getting all records of an entity
+ */
+type EntityGetAllRecordsOptions = EntityGetRecordsByIdOptions;
+/**
+ * Options for getting a single entity record by entity ID and record ID
+ */
+interface EntityGetRecordByIdOptions {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+}
+/**
+ * Common options for entity operations that modify multiple records
+ */
+interface EntityOperationOptions {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+    /** Whether to fail on first error (default: false) */
+    failOnFirst?: boolean;
+}
+/**
+ * Options for inserting a single record into an entity
+ * @deprecated Use {@link EntityInsertRecordOptions} instead for better clarity on inserting a single record into an entity. This type will be removed in future versions.
+ */
+interface EntityInsertOptions {
+    /** Level of entity expansion (default: 0) */
+    expansionLevel?: number;
+}
+/**
+ * Options for inserting a single record into an entity
+ */
+type EntityInsertRecordOptions = EntityInsertOptions;
+/**
+ * Options for batch inserting data into an entity
+ * @deprecated Use {@link EntityInsertRecordsOptions} instead for better clarity on inserting multiple records into an entity. This type will be removed in future versions.
+ */
+type EntityBatchInsertOptions = EntityOperationOptions;
+/**
+ * Options for inserting multiple records into an entity
+ */
+type EntityInsertRecordsOptions = EntityOperationOptions;
+/**
+ * Options for updating data in an entity
+ * @deprecated Use {@link EntityUpdateRecordOptions} instead for better clarity on updating records in an entity. This type will be removed in future versions.
+ */
+type EntityUpdateOptions = EntityOperationOptions;
+/**
+ * Options for updating data in an entity
+ */
+type EntityUpdateRecordsOptions = EntityOperationOptions;
+/**
+ * Options for deleting data from an entity
+ * @deprecated Use {@link EntityDeleteRecordsOptions} instead for better clarity on deleting records from an entity. This type will be removed in future versions.
+ */
+interface EntityDeleteOptions {
+    /** Whether to fail on first error (default: false) */
+    failOnFirst?: boolean;
+}
+/**
+ * Options for deleting records in an entity
+ */
+type EntityDeleteRecordsOptions = EntityDeleteOptions;
+/**
+ * Options for downloading an attachment from an entity record
+ */
+interface EntityDownloadAttachmentOptions {
+    /** Entity name */
+    entityName: string;
+    /** Record ID */
+    recordId: string;
+    /** Field name containing the attachment */
+    fieldName: string;
+}
+/**
+ * Represents a failure record in an entity operation
+ */
+interface FailureRecord {
+    /** Error message */
+    error?: string;
+    /** Original record that failed */
+    record?: Record<string, any>;
+}
+/**
+ * Response from an entity operation that modifies multiple records
+ */
+interface EntityOperationResponse {
+    /** Records that were successfully processed */
+    successRecords: Record<string, any>[];
+    /** Records that failed processing */
+    failureRecords: FailureRecord[];
+}
+/**
+ * Response from inserting a single record into an entity
+ * Returns the inserted record with its generated record ID and other fields
+ */
+type EntityInsertResponse = EntityRecord;
+/**
+ * Response from batch inserting data into an entity
+ */
+type EntityBatchInsertResponse = EntityOperationResponse;
+/**
+ * Response from updating data in an entity
+ */
+type EntityUpdateResponse = EntityOperationResponse;
+/**
+ * Response from deleting data from an entity
+ */
+type EntityDeleteResponse = EntityOperationResponse;
+/**
+ * Entity type enum
+ */
+declare enum EntityType {
+    Entity = "Entity",
+    ChoiceSet = "ChoiceSet",
+    InternalEntity = "InternalEntity",
+    SystemEntity = "SystemEntity"
+}
+/**
+ * Field type metadata
+ */
+interface FieldDataType {
+    name: EntityFieldDataType;
+    lengthLimit?: number;
+    maxValue?: number;
+    minValue?: number;
+    decimalPrecision?: number;
+}
+/**
+ * Reference types for fields
+ */
+declare enum ReferenceType {
+    ManyToOne = "ManyToOne"
+}
+/**
+ * Field display types
+ */
+declare enum FieldDisplayType {
+    Basic = "Basic",
+    Relationship = "Relationship",
+    File = "File",
+    ChoiceSetSingle = "ChoiceSetSingle",
+    ChoiceSetMultiple = "ChoiceSetMultiple",
+    AutoNumber = "AutoNumber"
+}
+/**
+ * Data direction type for external fields
+ */
+declare enum DataDirectionType {
+    ReadOnly = "ReadOnly",
+    ReadAndWrite = "ReadAndWrite"
+}
+/**
+ * Join type for source join criteria
+ */
+declare enum JoinType {
+    LeftJoin = "LeftJoin"
+}
+/**
+ * Field reference with ID
+ */
+interface Field {
+    id: string;
+    definition?: FieldMetaData;
+}
+/**
+ * Detailed field definition
+ */
+interface FieldMetaData {
+    id: string;
+    name: string;
+    isPrimaryKey: boolean;
+    isForeignKey: boolean;
+    isExternalField: boolean;
+    isHiddenField: boolean;
+    isUnique: boolean;
+    referenceName?: string;
+    referenceEntity?: RawEntityGetResponse;
+    referenceChoiceSet?: RawEntityGetResponse;
+    referenceField?: Field;
+    referenceType: ReferenceType;
+    fieldDataType: FieldDataType;
+    isRequired: boolean;
+    displayName: string;
+    description: string;
+    createdTime: string;
+    createdBy: string;
+    updatedTime: string;
+    updatedBy?: string;
+    isSystemField: boolean;
+    fieldDisplayType?: FieldDisplayType;
+    choiceSetId?: string;
+    defaultValue?: string;
+    isAttachment: boolean;
+    isRbacEnabled: boolean;
+}
+/**
+ * External object details
+ */
+interface ExternalObject {
+    id: string;
+    externalObjectName?: string;
+    externalObjectDisplayName?: string;
+    primaryKey?: string;
+    externalConnectionId: string;
+    entityId?: string;
+    isPrimarySource: boolean;
+}
+/**
+ * External connection details
+ */
+interface ExternalConnection {
+    id: string;
+    connectionId: string;
+    elementInstanceId: number;
+    folderKey: string;
+    connectorKey?: string;
+    connectorName?: string;
+    connectionName?: string;
+}
+/**
+ * External field mapping
+ */
+interface ExternalFieldMapping {
+    id: string;
+    externalFieldName?: string;
+    externalFieldDisplayName?: string;
+    externalObjectId: string;
+    externalFieldType?: string;
+    internalFieldId: string;
+    directionType: DataDirectionType;
+}
+/**
+ * External field
+ */
+interface ExternalField {
+    fieldMetaData: FieldMetaData;
+    externalFieldMappingDetail: ExternalFieldMapping;
+}
+/**
+ * External source fields
+ */
+interface ExternalSourceFields {
+    fields?: ExternalField[];
+    externalObjectDetail?: ExternalObject;
+    externalConnectionDetail?: ExternalConnection;
+}
+/**
+ * Source join criteria
+ */
+interface SourceJoinCriteria {
+    id: string;
+    entityId: string;
+    joinFieldName?: string;
+    joinType: JoinType;
+    relatedSourceObjectId?: string;
+    relatedSourceFieldName?: string;
+}
+/**
+ * Entity metadata returned by getById
+ */
+interface RawEntityGetResponse {
+    name: string;
+    displayName: string;
+    entityType: EntityType;
+    description: string;
+    fields: FieldMetaData[];
+    externalFields?: ExternalSourceFields[];
+    sourceJoinCriterias?: SourceJoinCriteria[];
+    recordCount?: number;
+    storageSizeInMB?: number;
+    usedStorageSizeInMB?: number;
+    attachmentSizeInByte?: number;
+    isRbacEnabled: boolean;
+    id: string;
+    createdBy: string;
+    createdTime: string;
+    updatedTime?: string;
+    updatedBy?: string;
+}
+
+/**
+ * Service for managing UiPath Data Fabric Entities.
+ *
+ * Entities are collections of records that can be used to store and manage data in the Data Fabric. [UiPath Data Fabric Guide](https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/introduction)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { Entities } from '@uipath/uipath-typescript/entities';
+ *
+ * const entities = new Entities(sdk);
+ * const allEntities = await entities.getAll();
+ * ```
+ */
+interface EntityServiceModel {
+    /**
+     * Gets all entities in the system
+     *
+     * @returns Promise resolving to either an array of entities NonPaginatedResponse<EntityGetResponse> or a PaginatedResponse<EntityGetResponse> when pagination options are used.
+     * {@link EntityGetResponse}
+     * @example
+     * ```typescript
+     * // Get all entities
+     * const allEntities = await entities.getAll();
+     *
+     * // Iterate through entities
+     * allEntities.forEach(entity => {
+     *   console.log(`Entity: ${entity.displayName} (${entity.name})`);
+     *   console.log(`Type: ${entity.entityType}`);
+     * });
+     *
+     * // Find a specific entity by name
+     * const customerEntity = allEntities.find(e => e.name === 'Customer');
+     *
+     * // Use entity methods directly
+     * if (customerEntity) {
+     *   const records = await customerEntity.getAllRecords();
+     *   console.log(`Customer records: ${records.items.length}`);
+     *
+     *   // Insert a single record
+     *   const insertResult = await customerEntity.insertRecord({ name: "John", age: 30 });
+     *
+     *   // Or batch insert multiple records
+     *   const batchResult = await customerEntity.insertRecords([
+     *     { name: "Jane", age: 25 },
+     *     { name: "Bob", age: 35 }
+     *   ]);
+     * }
+     * ```
+     */
+    getAll(): Promise<EntityGetResponse[]>;
+    /**
+     * Gets entity metadata by entity ID with attached operation methods
+     *
+     * @param id - UUID of the entity
+     * @returns Promise resolving to entity metadata with operation methods
+     * {@link EntityGetResponse}
+     * @example
+     * ```typescript
+     * import { Entities, ChoiceSets } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     * const choicesets = new ChoiceSets(sdk);
+     *
+     * // Get entity metadata with methods
+     * const entity = await entities.getById(<entityId>);
+     *
+     * // Call operations directly on the entity
+     * const records = await entity.getAllRecords();
+     *
+     * // If a field references a ChoiceSet, get the choiceSetId from records.fields
+     * const choiceSetId = records.fields[0].referenceChoiceSet?.id;
+     * if (choiceSetId) {
+     *   const choiceSetValues = await choicesets.getById(choiceSetId);
+     * }
+     *
+     * // Insert a single record
+     * const insertResult = await entity.insertRecord({ name: "John", age: 30 });
+     *
+     * // Or batch insert multiple records
+     * const batchResult = await entity.insertRecords([
+     *     { name: "Jane", age: 25 },
+     *     { name: "Bob", age: 35 }
+     * ]);
+     * ```
+     */
+    getById(id: string): Promise<EntityGetResponse>;
+    /**
+     * Gets entity records by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param options - Query options
+     * @returns Promise resolving to either an array of entity records NonPaginatedResponse<EntityRecord> or a PaginatedResponse<EntityRecord> when pagination options are used.
+     * {@link EntityRecord}
+     * @example
+     * ```typescript
+     * // Basic usage (non-paginated)
+     * const records = await entities.getAllRecords(<entityId>);
+     *
+     * // With expansion level
+     * const records = await entities.getAllRecords(<entityId>, {
+     *   expansionLevel: 1
+     * });
+     *
+     * // With pagination
+     * const paginatedResponse = await entities.getAllRecords(<entityId>, {
+     *   pageSize: 50,
+     *   expansionLevel: 1
+     * });
+     *
+     * // Navigate to next page
+     * const nextPage = await entities.getAllRecords(<entityId>, {
+     *   cursor: paginatedResponse.nextCursor,
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getAllRecords<T extends EntityGetAllRecordsOptions = EntityGetAllRecordsOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * @deprecated Use {@link getAllRecords} instead.
+     * @hidden
+     */
+    getRecordsById<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Gets a single entity record by entity ID and record ID
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record
+     * @param options - Query options
+     * @returns Promise resolving to a single entity record
+     * {@link EntityRecord}
+     * @example
+     * ```typescript
+     * // First, get records to obtain the record ID
+     * const records = await entities.getAllRecords(<entityId>);
+     * // Get the recordId for the record
+     * const recordId = records.items[0].id;
+     * // Get the record
+     * const record = await entities.getRecordById(<entityId>, recordId);
+     *
+     * // With expansion level
+     * const record = await entities.getRecordById(<entityId>, recordId, {
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getRecordById(entityId: string, recordId: string, options?: EntityGetRecordByIdOptions): Promise<EntityRecord>;
+    /**
+     * Inserts a single record into an entity by entity ID
+     *
+     * Note: Data Fabric supports trigger events only on individual inserts, not on inserting multiple records.
+     * Use this method if you need trigger events to fire for the inserted record.
+     *
+     * @param id - UUID of the entity
+     * @param data - Record to insert
+     * @param options - Insert options
+     * @returns Promise resolving to the inserted record with generated record ID
+     * {@link EntityInsertResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await entities.insertRecordById(<entityId>, { name: "John", age: 30 });
+     *
+     * // With options
+     * const result = await entities.insertRecordById(<entityId>, { name: "John", age: 30 }, {
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    insertRecordById(id: string, data: Record<string, any>, options?: EntityInsertRecordOptions): Promise<EntityInsertResponse>;
+    /**
+     * @deprecated Use {@link insertRecordById} instead.
+     * @hidden
+     */
+    insertById(id: string, data: Record<string, any>, options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * Inserts one or more records into an entity by entity ID
+     *
+     * Note: Records inserted using insertRecordsById will not trigger Data Fabric trigger events. Use {@link insertRecordById} if you need
+     * trigger events to fire for each inserted record.
+     *
+     * @param id - UUID of the entity
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to insert response
+     * {@link EntityBatchInsertResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await entities.insertRecordsById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ]);
+     *
+     * // With options
+     * const result = await entities.insertRecordsById(<entityId>, [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    insertRecordsById(id: string, data: Record<string, any>[], options?: EntityInsertRecordsOptions): Promise<EntityBatchInsertResponse>;
+    /**
+     * @deprecated Use {@link insertRecordsById} instead.
+     * @hidden
+     */
+    batchInsertById(id: string, data: Record<string, any>[], options?: EntityBatchInsertOptions): Promise<EntityBatchInsertResponse>;
+    /**
+     * Updates data in an entity by entity ID
+     *
+     * @param id - UUID of the entity
+     * @param data - Array of records to update. Each record MUST contain the record Id.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     * {@link EntityUpdateResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await entities.updateRecordsById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ]);
+     *
+     * // With options
+     * const result = await entities.updateRecordsById(<entityId>, [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    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
+     *
+     * @param id - UUID of the entity
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     * {@link EntityDeleteResponse}
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const result = await entities.deleteRecordsById(<entityId>, [
+     *   <recordId-1>, <recordId-2>
+     * ]);
+     * ```
+     */
+    deleteRecordsById(id: string, recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * @deprecated Use {@link deleteRecordsById} instead.
+     * @hidden
+     */
+    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Downloads an attachment stored in a File-type field of an entity record.
+     *
+     * @param options - Options containing entityName, recordId, and fieldName
+     * @returns Promise resolving to Blob containing the file content
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // First, get records to obtain the record ID
+     * const records = await entities.getAllRecords("<entityId>");
+     * // Get the recordId for the record that contains the attachment
+     * const recordId = records.items[0].id;
+     *
+     * // Download attachment using service method
+     * const response = await entities.downloadAttachment({
+     *   entityName: 'Invoice',
+     *   recordId: recordId,
+     *   fieldName: 'Documents'
+     * });
+     *
+     * // Or download using entity method
+     * const entity = await entities.getById("<entityId>");
+     * const blob = await entity.downloadAttachment(recordId, 'Documents');
+     *
+     * // Browser: Display Image
+     * const url = URL.createObjectURL(response);
+     * document.getElementById('image').src = url;
+     * // Call URL.revokeObjectURL(url) when done
+     *
+     * // Browser: Display PDF in iframe
+     * const url = URL.createObjectURL(response);
+     * document.getElementById('pdf-viewer').src = url;
+     * // Call URL.revokeObjectURL(url) when done
+     *
+     * // Browser: Render PDF with PDF.js
+     * const arrayBuffer = await response.arrayBuffer();
+     * const pdf = await pdfjsLib.getDocument({ data: arrayBuffer }).promise;
+     *
+     * // Node.js: Save to file
+     * const buffer = Buffer.from(await response.arrayBuffer());
+     * fs.writeFileSync('attachment.pdf', buffer);
+     * ```
+     */
+    downloadAttachment(options: EntityDownloadAttachmentOptions): Promise<Blob>;
+}
+/**
+ * Entity methods interface - defines operations that can be performed on an entity
+ */
+interface EntityMethods {
+    /**
+     * Insert a single record into this entity
+     *
+     * Note: Data Fabric supports trigger events only on individual inserts, not on inserting multiple records.
+     * Use this method if you need trigger events to fire for the inserted record.
+     *
+     * @param data - Record to insert
+     * @param options - Insert options
+     * @returns Promise resolving to the inserted record with generated record ID
+     */
+    insertRecord(data: Record<string, any>, options?: EntityInsertRecordOptions): Promise<EntityInsertResponse>;
+    /**
+     * Insert multiple records into this entity using insertRecords
+     *
+     * Note: Inserting multiple records do not trigger Data Fabric trigger events. Use {@link insertRecord} if you need
+     * trigger events to fire for each inserted record.
+     *
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to batch insert response
+     */
+    insertRecords(data: Record<string, any>[], options?: EntityInsertRecordsOptions): Promise<EntityBatchInsertResponse>;
+    /**
+     * Update data in this entity
+     *
+     * @param data - Array of records to update. Each record MUST contain the record Id,
+     *               otherwise the update will fail.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     */
+    updateRecords(data: EntityRecord[], options?: EntityUpdateRecordsOptions): Promise<EntityUpdateResponse>;
+    /**
+     * Delete data from this entity
+     *
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     */
+    deleteRecords(recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Get all records from this entity
+     *
+     * @param options - Query options
+     * @returns Promise resolving to query response
+     */
+    getAllRecords<T extends EntityGetAllRecordsOptions = EntityGetAllRecordsOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Gets a single record from this entity by record ID
+     *
+     * @param recordId - UUID of the record
+     * @param options - Query options including expansionLevel
+     * @returns Promise resolving to the entity record
+     */
+    getRecord(recordId: string, options?: EntityGetRecordByIdOptions): Promise<EntityRecord>;
+    /**
+     * Downloads an attachment stored in a File-type field of an entity record
+     *
+     * @param recordId - UUID of the record containing the attachment
+     * @param fieldName - Name of the File-type field containing the attachment
+     * @returns Promise resolving to Blob containing the file content
+     */
+    downloadAttachment(recordId: string, fieldName: string): Promise<Blob>;
+    /**
+     * @deprecated Use {@link insertRecord} instead.
+     * @hidden
+     */
+    insert(data: Record<string, any>, options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * @deprecated Use {@link insertRecords} instead.
+     * @hidden
+     */
+    batchInsert(data: Record<string, any>[], options?: EntityBatchInsertOptions): Promise<EntityBatchInsertResponse>;
+    /**
+   * @deprecated Use {@link updateRecords} instead.
+   * @hidden
+   */
+    update(data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    /**
+     * @deprecated Use {@link deleteRecords} instead.
+     * @hidden
+     */
+    delete(recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    /**
+     * @deprecated Use {@link getAllRecords} instead.
+     * @hidden
+     */
+    getRecords<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+}
+/**
+ * Entity with methods combining metadata with operation methods
+ */
+type EntityGetResponse = RawEntityGetResponse & EntityMethods;
+/**
+ * Creates an actionable entity metadata by combining entity with operational methods
+ *
+ * @param entityData - Entity metadata
+ * @param service - The entity service instance
+ * @returns Entity metadata with added methods
+ */
+declare function createEntityWithMethods(entityData: RawEntityGetResponse, service: EntityServiceModel): EntityGetResponse;
+
+/**
+ * Service for interacting with the Data Fabric Entity API
+ */
+declare class EntityService extends BaseService implements EntityServiceModel {
+    /**
+     * Gets entity metadata by entity ID with attached operation methods
+     *
+     * @param id - UUID of the entity
+     * @returns Promise resolving to entity metadata with schema information and operation methods
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     * const entity = await entities.getById("<entityId>");
+     *
+     * // Call operations directly on the entity
+     * const records = await entity.getAllRecords();
+     *
+     * // Insert a single record
+     * const insertResult = await entity.insertRecord({ name: "John", age: 30 });
+     *
+     * // Or batch insert multiple records
+     * const batchResult = await entity.insertRecords([
+     *     { name: "Jane", age: 25 },
+     *     { name: "Bob", age: 35 }
+     * ]);
+     * ```
+     */
+    getById(id: string): Promise<EntityGetResponse>;
+    /**
+     * Gets entity records by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param options - Query options including expansionLevel and pagination options
+     * @returns Promise resolving to an array of entity records or paginated response
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Basic usage (non-paginated)
+     * const records = await entities.getAllRecords("<entityId>");
+     *
+     * // With expansion level
+     * const records = await entities.getAllRecords("<entityId>", {
+     *   expansionLevel: 1
+     * });
+     *
+     * // With pagination
+     * const paginatedResponse = await entities.getAllRecords("<entityId>", {
+     *   pageSize: 50,
+     *   expansionLevel: 1
+     * });
+     *
+     * // Navigate to next page
+     * const nextPage = await entities.getAllRecords("<entityId>", {
+     *   cursor: paginatedResponse.nextCursor,
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getAllRecords<T extends EntityGetAllRecordsOptions = EntityGetAllRecordsOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * Gets a single entity record by entity ID and record ID
+     *
+     * @param entityId - UUID of the entity
+     * @param recordId - UUID of the record
+     * @param options - Query options including expansionLevel
+     * @returns Promise resolving to the entity record
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const record = await sdk.entities.getRecordById(<entityId>, <recordId>);
+     *
+     * // With expansion level
+     * const record = await sdk.entities.getRecordById(<entityId>, <recordId>, {
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    getRecordById(entityId: string, recordId: string, options?: EntityGetRecordByIdOptions): Promise<EntityRecord>;
+    /**
+     * Inserts a single record into an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param data - Record to insert
+     * @param options - Insert options
+     * @returns Promise resolving to the inserted record with generated record ID
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Basic usage
+     * const result = await entities.insertRecordById("<entityId>", { name: "John", age: 30 });
+     *
+     * // With options
+     * const result = await entities.insertRecordById("<entityId>", { name: "John", age: 30 }, {
+     *   expansionLevel: 1
+     * });
+     * ```
+     */
+    insertRecordById(id: string, data: Record<string, any>, options?: EntityInsertRecordOptions): Promise<EntityInsertResponse>;
+    /**
+     * Inserts data into an entity by entity ID using batch insert
+     *
+     * @param entityId - UUID of the entity
+     * @param data - Array of records to insert
+     * @param options - Insert options
+     * @returns Promise resolving to insert response
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Basic usage
+     * const result = await entities.insertRecordsById("<entityId>", [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ]);
+     *
+     * // With options
+     * const result = await entities.insertRecordsById("<entityId>", [
+     *   { name: "John", age: 30 },
+     *   { name: "Jane", age: 25 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    insertRecordsById(id: string, data: Record<string, any>[], options?: EntityInsertRecordsOptions): Promise<EntityBatchInsertResponse>;
+    /**
+     * Updates data in an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param data - Array of records to update. Each record MUST contain the record Id,
+     *               otherwise the update will fail.
+     * @param options - Update options
+     * @returns Promise resolving to update response
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Basic usage
+     * const result = await entities.updateRecordsById("<entityId>", [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ]);
+     *
+     * // With options
+     * const result = await entities.updateRecordsById("<entityId>", [
+     *   { Id: "123", name: "John Updated", age: 31 },
+     *   { Id: "456", name: "Jane Updated", age: 26 }
+     * ], {
+     *   expansionLevel: 1,
+     *   failOnFirst: true
+     * });
+     * ```
+     */
+    updateRecordsById(id: string, data: EntityRecord[], options?: EntityUpdateRecordsOptions): Promise<EntityUpdateResponse>;
+    /**
+     * Deletes data from an entity by entity ID
+     *
+     * @param entityId - UUID of the entity
+     * @param recordIds - Array of record UUIDs to delete
+     * @param options - Delete options
+     * @returns Promise resolving to delete response
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Basic usage
+     * const result = await entities.deleteRecordsById("<entityId>", [
+     *   "<recordId-1>", "<recordId-2>"
+     * ]);
+     * ```
+     */
+    deleteRecordsById(id: string, recordIds: string[], options?: EntityDeleteRecordsOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Gets all entities in the system
+     *
+     * @returns Promise resolving to an array of entity metadata
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Get all entities
+     * const allEntities = await entities.getAll();
+     *
+     * // Call operations on an entity
+     * const records = await allEntities[0].getAllRecords();
+     * ```
+     */
+    getAll(): Promise<EntityGetResponse[]>;
+    /**
+     * Downloads an attachment from an entity record field
+     *
+     * @param options - Options containing entityName, recordId, and fieldName
+     * @returns Promise resolving to Blob containing the file content
+     *
+     * @example
+     * ```typescript
+     * import { Entities } from '@uipath/uipath-typescript/entities';
+     *
+     * const entities = new Entities(sdk);
+     *
+     * // Download attachment for a specific record and field
+     * const blob = await entities.downloadAttachment({
+     *   entityName: 'Invoice',
+     *   recordId: '<record-uuid>',
+     *   fieldName: 'Documents'
+     * });
+     */
+    downloadAttachment(options: EntityDownloadAttachmentOptions): Promise<Blob>;
+    /**
+   * @hidden
+   * @deprecated Use {@link getAllRecords} instead.
+   */
+    getRecordsById<T extends EntityGetRecordsByIdOptions = EntityGetRecordsByIdOptions>(entityId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<EntityRecord> : NonPaginatedResponse<EntityRecord>>;
+    /**
+     * @hidden
+     * @deprecated Use {@link insertRecordById} instead.
+     */
+    insertById(id: string, data: Record<string, any>, options?: EntityInsertOptions): Promise<EntityInsertResponse>;
+    /**
+     * @hidden
+     * @deprecated Use {@link insertRecordsById} instead.
+     */
+    batchInsertById(id: string, data: Record<string, any>[], options?: EntityBatchInsertOptions): Promise<EntityBatchInsertResponse>;
+    /**
+     * @hidden
+     * @deprecated Use {@link updateRecordsById} instead.
+     */
+    updateById(id: string, data: EntityRecord[], options?: EntityUpdateOptions): Promise<EntityUpdateResponse>;
+    /**
+     * @hidden
+     * @deprecated Use {@link deleteRecordsById} instead.
+     */
+    deleteById(id: string, recordIds: string[], options?: EntityDeleteOptions): Promise<EntityDeleteResponse>;
+    /**
+     * Orchestrates all field mapping transformations
+     *
+     * @param metadata - Entity metadata to transform
+     * @private
+     */
+    private applyFieldMappings;
+    /**
+     * Maps SQL field types to friendly EntityFieldTypes
+     *
+     * @param metadata - Entity metadata with fields
+     * @private
+     */
+    private mapFieldTypes;
+    /**
+     * Transforms nested reference objects in field metadata
+     */
+    private transformNestedReferences;
+    /**
+     * Maps external field names to consistent naming
+     *
+     * @param metadata - Entity metadata with externalFields
+     * @private
+     */
+    private mapExternalFields;
+}
+
+/**
+ * ChoiceSet Get All Response
+ * Only exposes essential fields to SDK users
+ */
+interface ChoiceSetGetAllResponse {
+    /** Name identifier of the choice set */
+    name: string;
+    /** Human-readable display name of the choice set*/
+    displayName: string;
+    /** Description of the choice set */
+    description: string;
+    /** Folder ID where the choice set is located */
+    folderId: string;
+    /** User ID who created the choice set */
+    createdBy: string;
+    /** User ID who last updated the choice set */
+    updatedBy: string;
+    /** Creation timestamp */
+    createdTime: string;
+    /** Last update timestamp */
+    updatedTime: string;
+}
+/**
+ * Represents a single choice set value/record
+ */
+interface ChoiceSetGetResponse {
+    /** Unique identifier for the choice set value */
+    id: string;
+    /** Name of the choice set value */
+    name: string;
+    /** Human-readable display name of the choice set value*/
+    displayName: string;
+    /** Numeric identifier */
+    numberId: number;
+    /** Creation timestamp */
+    createdTime: string;
+    /** Last update timestamp */
+    updatedTime: string;
+    /** User ID who created this value */
+    createdBy?: string;
+    /** User ID who last updated this value */
+    updatedBy?: string;
+    /** User ID of the record owner */
+    recordOwner?: string;
+}
+/**
+ * Options for getting choice set values by choice set ID
+ */
+type ChoiceSetGetByIdOptions = PaginationOptions;
+
+/**
+ * Service for managing UiPath Data Fabric Choice Sets
+ *
+ * Choice Sets are enumerated lists of values that can be used as field types in entities. They enable single-select or multi-select fields, such as expense types, categories, or status values. [UiPath Choice Sets Guide](https://docs.uipath.com/data-service/automation-cloud/latest/user-guide/choice-sets)
+ *
+ * ### Usage
+ *
+ * Prerequisites: Initialize the SDK first - see [Getting Started](/uipath-typescript/getting-started/#import-initialize)
+ *
+ * ```typescript
+ * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
+ *
+ * const choicesets = new ChoiceSets(sdk);
+ * const allChoiceSets = await choicesets.getAll();
+ * ```
+ */
+interface ChoiceSetServiceModel {
+    /**
+     * Gets all choice sets in the org
+     *
+     * @returns Promise resolving to an array of choice set metadata
+     * {@link ChoiceSetGetAllResponse}
+     * @example
+     * ```typescript
+     * // Get all choice sets
+     * const allChoiceSets = await choicesets.getAll();
+     *
+     * // Iterate through choice sets
+     * allChoiceSets.forEach(choiceSet => {
+     *   console.log(`ChoiceSet: ${choiceSet.displayName} (${choiceSet.name})`);
+     *   console.log(`Description: ${choiceSet.description}`);
+     *   console.log(`Created by: ${choiceSet.createdBy}`);
+     * });
+     *
+     * // Find a specific choice set by name
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'ExpenseTypes');
+     *
+     * // Check choice set details
+     * if (expenseTypes) {
+     *   console.log(`Last updated: ${expenseTypes.updatedTime}`);
+     *   console.log(`Updated by: ${expenseTypes.updatedBy}`);
+     * }
+     * ```
+     */
+    getAll(): Promise<ChoiceSetGetAllResponse[]>;
+    /**
+     * Gets choice set values by choice set ID with optional pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param choiceSetId - UUID of the choice set
+     * @param options - Pagination options
+     * @returns Promise resolving to choice set values or paginated result
+     * {@link ChoiceSetGetResponse}
+     * @example
+     * ```typescript
+     * // First, get the choice set ID using getAll()
+     * const allChoiceSets = await choicesets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'ExpenseTypes');
+     * const choiceSetId = expenseTypes.id;
+     *
+     * // Get all values (non-paginated)
+     * const values = await choicesets.getById(choiceSetId);
+     *
+     * // Iterate through choice set values
+     * for (const value of values.items) {
+     *   console.log(`Value: ${value.displayName}`);
+     * }
+     *
+     * // First page with pagination
+     * const page1 = await choicesets.getById(choiceSetId, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await choicesets.getById(choiceSetId, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    getById<T extends ChoiceSetGetByIdOptions = ChoiceSetGetByIdOptions>(choiceSetId: string, options?: T): Promise<T extends HasPaginationOptions<T> ? PaginatedResponse<ChoiceSetGetResponse> : NonPaginatedResponse<ChoiceSetGetResponse>>;
+}
+
+declare class ChoiceSetService extends BaseService implements ChoiceSetServiceModel {
+    /**
+     * Gets all choice sets in the system
+     *
+     * @returns Promise resolving to an array of choice set metadata
+     *
+     * @example
+     * ```typescript
+     * import { ChoiceSets } from '@uipath/uipath-typescript/entities';
+     *
+     * const choiceSets = new ChoiceSets(sdk);
+     *
+     * // Get all choice sets
+     * const allChoiceSets = await choiceSets.getAll();
+     *
+     * // Iterate through choice sets
+     * allChoiceSets.forEach(choiceSet => {
+     *   console.log(`ChoiceSet: ${choiceSet.displayName} (${choiceSet.name})`);
+     *   console.log(`Description: ${choiceSet.description}`);
+     * });
+     * ```
+     */
+    getAll(): Promise<ChoiceSetGetAllResponse[]>;
+    /**
+     * Gets choice set values by choice set ID with optional pagination
+     *
+     * The method returns either:
+     * - A NonPaginatedResponse with items array (when no pagination parameters are provided)
+     * - A PaginatedResponse with navigation cursors (when any pagination parameter is provided)
+     *
+     * @param choiceSetId - UUID of the choice set
+     * @param options - Pagination options
+     * @returns Promise resolving to choice set values or paginated result
+     *
+     * @example
+     * ```typescript
+     * import { ChoiceSets } from '@uipath/uipath-typescript/choicesets';
+     *
+     * const choiceSets = new ChoiceSets(sdk);
+     *
+     * // First, get the choice set ID using getAll()
+     * const allChoiceSets = await choiceSets.getAll();
+     * const expenseTypes = allChoiceSets.find(cs => cs.name === 'ExpenseTypes');
+     * const choiceSetId = expenseTypes.id;
+     *
+     * // Get all values (non-paginated)
+     * const values = await choiceSets.getById(choiceSetId);
+     *
+     * // Iterate through choice set values
+     * for (const value of values.items) {
+     *   console.log(`Value: ${value.displayName} (${value.name})`);
+     * }
+     *
+     * // First page with pagination
+     * const page1 = await choiceSets.getById(choiceSetId, { pageSize: 10 });
+     *
+     * // Navigate using cursor
+     * if (page1.hasNextPage) {
+     *   const page2 = await choiceSets.getById(choiceSetId, { cursor: page1.nextCursor });
+     * }
+     * ```
+     */
+    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, EntityDeleteOptions, EntityDeleteRecordsOptions, EntityDeleteResponse, EntityDownloadAttachmentOptions, EntityGetAllRecordsOptions, EntityGetRecordByIdOptions, EntityGetRecordsByIdOptions, EntityGetResponse, EntityInsertOptions, EntityInsertRecordOptions, EntityInsertRecordsOptions, EntityInsertResponse, EntityMethods, EntityOperationOptions, EntityOperationResponse, EntityRecord, EntityServiceModel, EntityUpdateOptions, EntityUpdateRecordsOptions, EntityUpdateResponse, ExternalConnection, ExternalField, ExternalFieldMapping, ExternalObject, ExternalSourceFields, FailureRecord, Field, FieldDataType, FieldMetaData, RawEntityGetResponse, SourceJoinCriteria };