@or-sdk/hitl 0.36.2 → 0.36.3

package/dist/types/api/Migrations.d.ts

@@ -1,19 +1,241 @@
 import { ApiVersionOptions } from '../types';
 import { GetMigrationsOptions, GetMigrationsResponse, RunMigrationsOptions, RunMigrationsResponse, CreateDefaultRecordsResponse, GetMigrationsInfoResponse, GetRunMigrationsStatusResponse, GetDefaultRecordsOptions, GetDefaultRecordsResponse, SyncDefaultRecordsOptions, SyncDefaultRecordsResponse } from '../types/migrations';
 import { HITLBase } from './HITLBase';
+/**
+ * Manages database migrations and default records in the system
+ *
+ * This class provides functionality to:
+ * - Manage database migrations
+ * - Handle default records for tables
+ * - Monitor migration status
+ * - Control migration locks
+ *
+ * @remarks
+ * - All methods in this class interact with the `/migrations` endpoint
+ * @public
+ */
 export declare class Migrations extends HITLBase {
     protected static readonly MODULE_URL = "migrations";
     protected static DEFAULT_RECORDS_URL: string;
     protected static MIGRATIONS_INFO_URL: string;
     protected static MIGRATIONS_LOCK_URL: string;
     protected static MIGRATIONS_STATUS_URL: string;
+    /**
+     * Retrieves a list of pending migrations
+     *
+     * @param options - Configuration parameters for retrieving migrations
+     *
+     * Optional parameters:
+     * - `appVersion` - (string) Application version to check migrations against
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetMigrationsResponse>} Promise resolving to the list of pending migrations
+     *
+     * @example
+     * ```typescript
+     * const migrations = await hitlApi.migrations.getListOfMigrations({
+     *   appVersion: '0.81.0',
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/migrations` endpoint
+     * @public
+     */
     static getListOfMigrations({ appVersion, ...options }?: GetMigrationsOptions): Promise<GetMigrationsResponse>;
+    /**
+     * Executes pending migrations
+     *
+     * @param options - Configuration parameters for running migrations
+     *
+     * Optional parameters:
+     * - `appVersion` - (string) Version of the application to migrate for
+     * - `meta` - (object) Additional metadata for the migration
+     * - `method` - ("up" | "down") Direction of migration, either "up" or "down"
+     * - `name` - (string) Name of specific migration to run
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<void>} Promise that resolves when migrations are complete
+     *
+     * @example
+     * ```typescript
+     * // Run all migrations up to latest version
+     * await migrationApi.runAllMigrations();
+     *
+     * // Run specific migration with metadata
+     * await migrationApi.runAllMigrations({
+     *   name: "27-create-contact-rule-groups-table",
+     *   method: "up",
+     *   meta: {
+     *     appVersion: "0.81.0",
+     *   }
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a POST request to the `/migrations` endpoint
+     * @public
+     */
     static runAllMigrations({ meta, ...options }?: RunMigrationsOptions): Promise<RunMigrationsResponse>;
+    /**
+     * Retrieves the current status of running migrations
+     *
+     * @param options - Configuration parameters
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetRunMigrationsStatusResponse>} Promise resolving to the migration status
+     *
+     * @example
+     * ```typescript
+     * const status = await hitlApi.migrations.getRunMigrationsStatus();
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/migrations/status` endpoint
+     * @public
+     */
     static getRunMigrationsStatus(options?: ApiVersionOptions): Promise<GetRunMigrationsStatusResponse>;
+    /**
+     * Removes the migrations table lock that is set during migration runs
+     *
+     * @param options - Configuration parameters
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<void>} Promise that resolves when the lock is deleted
+     *
+     * @example
+     * ```typescript
+     * await hitlApi.migrations.deleteMigrationsTableLock();
+     * ```
+     *
+     * @remarks
+     * Makes a DELETE request to the `/migrations/lock` endpoint
+     * @public
+     */
     static deleteMigrationsTableLock(options?: ApiVersionOptions): Promise<unknown>;
+    /**
+     * Retrieves migration compatibility information with UI versions
+     *
+     * @param options - Configuration parameters
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetMigrationsInfoResponse>} Promise resolving to the migrations compatibility info
+     *
+     * @example
+     * ```typescript
+     * const info = await hitlApi.migrations.getMigrationsInfo();
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/migrations/info` endpoint
+     * @public
+     */
     static getMigrationsInfo(options?: ApiVersionOptions): Promise<GetMigrationsInfoResponse>;
+    /**
+     * Retrieves default records for specific tables
+     *
+     * Supported tables:
+     * - settings
+     * - filters
+     * - event_templates
+     * - rule_groups
+     *
+     * @param options - Configuration parameters for retrieving default records
+     *
+     * Required parameters:
+     * - `tableName` - ({@link DEFAULT_DATA_TABLE_NAME}) Name of the table to retrieve default records from
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetDefaultRecordsResponse>} Promise resolving to the default records
+     *
+     * @example
+     * ```typescript
+     * const records = await hitlApi.migrations.getTableDefaultRecords({
+     *   tableName: 'EVENT_TEMPLATES'
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/migrations/default-records` endpoint
+     * @public
+     */
     static getTableDefaultRecords(options: GetDefaultRecordsOptions): Promise<GetDefaultRecordsResponse>;
+    /**
+     * Creates default records for specific tables
+     *
+     * Supported tables:
+     * - settings
+     * - filters
+     * - event_templates
+     * - rule_groups
+     *
+     * @param options - Configuration parameters
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<CreateDefaultRecordsResponse>} Promise resolving to the created records
+     *
+     * @example
+     * ```typescript
+     * const result = await hitlApi.migrations.createTableDefaultRecords();
+     * ```
+     *
+     * @remarks
+     * Makes a POST request to the `/migrations/default-records` endpoint
+     * @public
+     */
     static createTableDefaultRecords(options?: ApiVersionOptions): Promise<CreateDefaultRecordsResponse>;
+    /**
+     * Synchronizes default records for specific tables
+     *
+     * Supported tables:
+     * - settings
+     * - filters
+     * - event_templates
+     * - rule_groups
+     *
+     * @param options - Configuration parameters for syncing records
+     *
+     * Optional parameters:
+     * - `keys` - (string[]) Array of specific record keys to synchronize. If not provided, all records will be synchronized
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<SyncDefaultRecordsResponse>} Promise resolving to the sync results
+     *
+     * @example
+     * // Sync all default records
+     * await tableApi.syncTableDefaultRecords({
+     *   tableName: DEFAULT_DATA_TABLE_NAME.FILTERS
+     * });
+     *
+     * // Sync specific records by keys
+     * await tableApi.syncTableDefaultRecords({
+     *   tableName: DEFAULT_DATA_TABLE_NAME.FILTERS,
+     *   keys: ['filter-id-1', 'filter-id-3']
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a PUT request to the `/migrations/default-records` endpoint
+     * @public
+     */
     static syncTableDefaultRecords(options: SyncDefaultRecordsOptions): Promise<SyncDefaultRecordsResponse>;
 }
 //# sourceMappingURL=Migrations.d.ts.map

package/dist/types/api/Migrations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Migrations.d.ts","sourceRoot":"","sources":["../../../src/api/Migrations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAGL,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,8BAA8B,EAC9B,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAetC,qBAAa,UAAW,SAAQ,QAAQ;IACtC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IACpD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAqB;IACzD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,qBAAqB,SAAY;WAyB9B,mBAAmB,CACrC,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,GAAE,oBAAyB,GACpD,OAAO,CAAC,qBAAqB,CAAC;WA4Cb,gBAAgB,CAClC,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,GAAE,oBAAyB,GAC9C,OAAO,CAAC,qBAAqB,CAAC;WAmCb,sBAAsB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC;WA8BhG,yBAAyB,CAAC,OAAO,GAAE,iBAAsB;WA+BzD,iBAAiB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,yBAAyB,CAAC;WAyCtF,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;WAyC7F,yBAAyB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,4BAA4B,CAAC;WA8CjG,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,0BAA0B,CAAC;CAcrH"}
+{"version":3,"file":"Migrations.d.ts","sourceRoot":"","sources":["../../../src/api/Migrations.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC7C,OAAO,EAGL,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,8BAA8B,EAC9B,wBAAwB,EACxB,yBAAyB,EACzB,yBAAyB,EACzB,0BAA0B,EAC3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;GAYG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,gBAAgB;IACpD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAqB;IACzD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,qBAAqB,SAAY;IAElD;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACiB,mBAAmB,CACrC,EAAE,UAAU,EAAE,GAAG,OAAO,EAAE,GAAE,oBAAyB,GACpD,OAAO,CAAC,qBAAqB,CAAC;IAUjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;WACiB,gBAAgB,CAClC,EAAE,IAAI,EAAE,GAAG,OAAO,EAAE,GAAE,oBAAyB,GAC9C,OAAO,CAAC,qBAAqB,CAAC;IAejC;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,sBAAsB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,8BAA8B,CAAC;IAUpH;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,yBAAyB,CAAC,OAAO,GAAE,iBAAsB;IAW7E;;;;;;;;;;;;;;;;;;;OAmBG;WACiB,iBAAiB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAU1G;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;WACiB,sBAAsB,CAAC,OAAO,EAAE,wBAAwB,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAejH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,yBAAyB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAWrH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;WACiB,uBAAuB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,0BAA0B,CAAC;CAcrH"}

package/dist/types/api/RuleGroups.d.ts

@@ -1,10 +1,137 @@
 import { SearchRuleGroupsOptions, SearchRuleGroupsResponse, RuleGroup, CreateRuleGroupOptions, UpdateRuleGroupOptions, DeleteRuleGroupOptions } from '../types/rule-groups';
 import { HITLBase } from './HITLBase';
+/**
+ * Manages rule groups in the system
+ *
+ * This class provides functionality to manage rule groups, including searching,
+ * creating, updating, and deleting rule groups.
+ *
+ * Key features:
+ * - Search and retrieve rule groups
+ * - Create new rule groups
+ * - Update existing rule groups
+ * - Delete rule groups
+ *
+ * @remarks
+ * - All methods in this class interact with the `/rule-groups` endpoint
+ * @public
+ */
 export declare class RuleGroups extends HITLBase {
     protected static MODULE_URL: string;
+    /**
+     * Searches for rule groups or retrieves specific groups
+     *
+     * @param options - Configuration parameters for the rule groups search
+     *
+     * Optional parameters:
+     * - `groupIdList` - (string[]) List of specific group IDs to retrieve
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<SearchRuleGroupsResponse | RuleGroup>} Promise resolving to:
+     * - Either a list of rule groups or a single rule group if specific ID is provided
+     *
+     * @example
+     * ```typescript
+     * // Search all rule groups
+     * const response = await hitlApi.ruleGroups.searchRuleGroups();
+     *
+     * // Search specific rule groups
+     * const groups = await hitlApi.ruleGroups.searchRuleGroups({
+     *   groupIdList: ['group-1', 'group-2']
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/rule-groups` endpoint
+     * @public
+     */
     static searchRuleGroups({ groupIdList, ...options }?: SearchRuleGroupsOptions): Promise<SearchRuleGroupsResponse | RuleGroup>;
+    /**
+     * Creates a new rule group
+     *
+     * @param options - Configuration parameters for creating the rule group
+     *
+     * Required parameters:
+     * - `groupId` - (string) Unique identifier for the group
+     * - `name` - (string) Name of the rule group
+     * - `rules` - (RuleDefinition[]) Array of rules for the group
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<RuleGroup>} Promise resolving to the created rule group
+     *
+     * @example
+     * ```typescript
+     * const newGroup = await hitlApi.ruleGroups.createRuleGroup({
+     *   groupId: 'group-1',
+     *   name: 'Allow sms',
+     *   rules: ['sms']
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a POST request to the `/rule-groups` endpoint
+     * @public
+     */
     static createRuleGroup({ groupId, name, rules, ...options }: CreateRuleGroupOptions): Promise<RuleGroup>;
+    /**
+     * Updates an existing rule group
+     *
+     * @param options - Configuration parameters for updating the rule group
+     *
+     * Required parameters:
+     * - `groupId` - (string) ID of the group to update
+     * - `name` - (string) Updated name for the rule group
+     * - `rules` - (RuleDefinition[]) Updated array of rules
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<RuleGroup>} Promise resolving to the updated rule group
+     *
+     * @example
+     * ```typescript
+     * const updatedGroup = await hitlApi.ruleGroups.updateRuleGroup({
+     *   groupId: 'group-1',
+     *   name: 'Default sms',
+     *   rules: ['sms', 'hitl']
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a PUT request to the `/rule-groups` endpoint
+     * @public
+     */
     static updateRuleGroup({ groupId, name, rules, ...options }: UpdateRuleGroupOptions): Promise<RuleGroup>;
+    /**
+     * Deletes a rule group
+     *
+     * @param options - Configuration parameters for deleting the rule group
+     *
+     * Required parameters:
+     * - `groupId` - (string) ID of the group to delete
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<void>} Promise that resolves when deletion is complete
+     *
+     * @example
+     * ```typescript
+     * await hitlApi.ruleGroups.deleteRuleGroup({
+     *   groupId: 'group-1'
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a DELETE request to the `/rule-groups` endpoint
+     * @public
+     */
     static deleteRuleGroup({ groupId, ...options }: DeleteRuleGroupOptions): Promise<void>;
 }
 //# sourceMappingURL=RuleGroups.d.ts.map

package/dist/types/api/RuleGroups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RuleGroups.d.ts","sourceRoot":"","sources":["../../../src/api/RuleGroups.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,SAAS,EACT,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAkBtC,qBAAa,UAAW,SAAQ,QAAQ;IACtC,SAAS,CAAC,MAAM,CAAC,UAAU,SAAiB;WA8B9B,gBAAgB,CAC5B,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE,GAAE,uBAA4B,GACxD,OAAO,CAAC,wBAAwB,GAAG,SAAS,CAAC;WA2ClC,eAAe,CAC3B,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC3D,OAAO,CAAC,SAAS,CAAC;WA4CP,eAAe,CAC3B,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC3D,OAAO,CAAC,SAAS,CAAC;WAwCP,eAAe,CAC3B,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC9C,OAAO,CAAC,IAAI,CAAC;CAUjB"}
+{"version":3,"file":"RuleGroups.d.ts","sourceRoot":"","sources":["../../../src/api/RuleGroups.ts"],"names":[],"mappings":"AACA,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,SAAS,EACT,sBAAsB,EACtB,sBAAsB,EACtB,sBAAsB,EACvB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;;;;GAeG;AACH,qBAAa,UAAW,SAAQ,QAAQ;IACtC,SAAS,CAAC,MAAM,CAAC,UAAU,SAAiB;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;WACW,gBAAgB,CAC5B,EAAE,WAAW,EAAE,GAAG,OAAO,EAAE,GAAE,uBAA4B,GACxD,OAAO,CAAC,wBAAwB,GAAG,SAAS,CAAC;IAchD;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACW,eAAe,CAC3B,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC3D,OAAO,CAAC,SAAS,CAAC;IAerB;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACW,eAAe,CAC3B,EAAE,OAAO,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC3D,OAAO,CAAC,SAAS,CAAC;IAerB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;WACW,eAAe,CAC3B,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,sBAAsB,GAC9C,OAAO,CAAC,IAAI,CAAC;CAUjB"}

package/dist/types/api/SessionEvents.d.ts

@@ -1,15 +1,160 @@
 import { GetNewEventsCountOptions, GetNewEventsCountResponse, SaveLastReadEventOptions } from '../types/read-events';
 import { GetSessionEventsOptions, GetSessionEventsResponse, AddEventsOptions, AddEventsResponse, GetBulkSessionEventsOptions, GetBulkSessionsEventsResponse } from '../types/session-events';
 import { HITLBase } from './HITLBase';
+/**
+ * Manages events for Human-in-the-Loop (HitL) sessions
+ *
+ * This class provides functionality to:
+ * - Retrieve and manage session events
+ * - Track event read status
+ * - Handle bulk event operations
+ * - Manage event counts
+ *
+ * @remarks
+ * - All methods interact with the `/session-events` endpoint
+ * @public
+ */
 export declare class SessionEvents extends HITLBase {
     protected static MODULE_URL: string;
     protected static GET_BULK_EVENTS_URL: string;
     protected static GET_EVENTS_COUNT_URL: string;
     protected static SAVE_READ_EVENT_URL: string;
+    /**
+     * Retrieves events for a specific HitL session
+     *
+     * @param options - Configuration parameters for retrieving session events
+     *
+     * Required parameters:
+     * - `sessionId` - (string) ID of the session to retrieve events for
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<SessionEvent[]>} Promise resolving to the list of session events
+     *
+     * @example
+     * ```typescript
+     * const events = await hitlApi.sessionEvents.getSessionEventsList({
+     *   sessionId: 'session-id'
+     * });
+     * ```
+     *
+     * @remarks Makes a GET request to `/session-events`
+     * @public
+     */
     static getSessionEventsList(options: GetSessionEventsOptions): Promise<GetSessionEventsResponse>;
+    /**
+     * Retrieves events for multiple HitL sessions in bulk
+     *
+     * @param options - Configuration parameters for bulk event retrieval
+     *
+     * Required parameters:
+     * - `sessionIds` - (string[]) Array of session IDs to retrieve events for
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetBulkSessionsEventsResponse>} Promise resolving to events for multiple sessions
+     *
+     * @example
+     * ```typescript
+     * const bulkEvents = await hitlApi.sessionEvents.getBulkSessionEventsList({
+     *   sessionIds: ['session-id-1', 'session-id-2']
+     * });
+     * ```
+     *
+     * @remarks Makes a POST request to `/session-events/bulk`
+     * @public
+     */
     static getBulkSessionEventsList(options: GetBulkSessionEventsOptions): Promise<GetBulkSessionsEventsResponse>;
+    /**
+     * Adds new events to a HITL session
+     *
+     * @param options - Configuration parameters for adding session events
+     *
+     * Required parameters:
+     * - `events` - (Partial<SessionEvent>[]) Array of partial event objects
+     * - `sessionId` - (string) ID of the session to add events to
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<AddEventsResult>} Promise resolving to the add operation result
+     *
+     * @example
+     * ```typescript
+     * const result = await hitlApi.sessionEvents.addEvents({
+     *   sessionId: 'session-id',
+     *   events: [
+     *     { type: 'message', content: 'Hello' },
+     *     { type: 'status', content: 'typing' }
+     *   ]
+     * });
+     * ```
+     *
+     * @remarks Makes a POST request to `/session-events`
+     * @public
+     */
     static addEvents({ sessionId, events, ...options }: AddEventsOptions): Promise<AddEventsResponse>;
+    /**
+     * Retrieves count of unread events for specified sessions
+     *
+     * @param options - Configuration parameters for retrieving unread events count
+     *
+     * Required parameters:
+     * - `sessionIds` - (string[]) Array of session IDs to get events count for
+     *
+     * Optional parameters:
+     * - `agentId` - (string) ID of the agent to get unread events for
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<NewEventsCount>} Promise resolving to the unread events count
+     *
+     * @example
+     * ```typescript
+     * // Basic usage with required parameters
+     * const count = await hitlApi.sessionEvents.getNewEventsCount({
+     *   sessionIds: ['session-id-1', 'session-id-2']
+     * });
+     * ```
+     *
+     * @remarks Makes a GET request to `/sessions-events/get-new-events`
+     * @public
+     */
     static getNewEventsCount({ agentId, ...options }: GetNewEventsCountOptions): Promise<GetNewEventsCountResponse>;
+    /**
+     * Records the last read event for a specific session
+     *
+     * @param options - Configuration parameters for saving last read event
+     *
+     * Required parameters:
+     * - `eventId` - (string) ID of the last read event
+     * - `eventTimestamp` - (string | number) Timestamp of the last read event
+     * - `sessionId` - (string) ID of the session
+     *
+     * Optional parameters:
+     * - `agentId` - (string) ID of the agent who read the event
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<void>} Promise resolving when the read status is saved
+     *
+     * @example
+     * ```typescript
+     * await hitlApi.sessionEvents.saveLastReadEvent({
+     *   sessionId: 'session-id-1',
+     *   eventId: 'event-id-2',
+     *   eventTimestamp: Date.now()
+     * });
+     * ```
+     *
+     * @remarks Makes a POST request to `/sessions-events/save-read-event`
+     * @public
+     */
     static saveReadEventByUserId({ agentId, ...options }: SaveLastReadEventOptions): Promise<void>;
 }
 //# sourceMappingURL=SessionEvents.d.ts.map

package/dist/types/api/SessionEvents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SessionEvents.d.ts","sourceRoot":"","sources":["../../../src/api/SessionEvents.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGL,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAetC,qBAAa,aAAc,SAAQ,QAAQ;IACzC,SAAS,CAAC,MAAM,CAAC,UAAU,SAAoB;IAC/C,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,oBAAoB,SAAoB;IACzD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAqB;WA0BrC,oBAAoB,CACtC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,wBAAwB,CAAC;WAsChB,wBAAwB,CAC1C,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,6BAA6B,CAAC;WA4C3B,SAAS,CACrB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,EAAE,gBAAgB,GAClD,OAAO,CAAC,iBAAiB,CAAC;WAsCT,iBAAiB,CACnC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,wBAAwB,GAChD,OAAO,CAAC,yBAAyB,CAAC;WA6CjB,qBAAqB,CACvC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,wBAAwB,GAChD,OAAO,CAAC,IAAI,CAAC;CAejB"}
+{"version":3,"file":"SessionEvents.d.ts","sourceRoot":"","sources":["../../../src/api/SessionEvents.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,wBAAwB,EACxB,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAGL,uBAAuB,EACvB,wBAAwB,EACxB,gBAAgB,EAChB,iBAAiB,EACjB,2BAA2B,EAC3B,6BAA6B,EAC9B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,SAAQ,QAAQ;IACzC,SAAS,CAAC,MAAM,CAAC,UAAU,SAAoB;IAC/C,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAU;IAC9C,SAAS,CAAC,MAAM,CAAC,oBAAoB,SAAoB;IACzD,SAAS,CAAC,MAAM,CAAC,mBAAmB,SAAqB;IAEzD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACiB,oBAAoB,CACtC,OAAO,EAAE,uBAAuB,GAC/B,OAAO,CAAC,wBAAwB,CAAC;IAcpC;;;;;;;;;;;;;;;;;;;;;;;OAuBG;WACiB,wBAAwB,CAC1C,OAAO,EAAE,2BAA2B,GACnC,OAAO,CAAC,6BAA6B,CAAC;IAezC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACW,SAAS,CACrB,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,EAAE,gBAAgB,GAClD,OAAO,CAAC,iBAAiB,CAAC;IAY7B;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,iBAAiB,CACnC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,wBAAwB,GAChD,OAAO,CAAC,yBAAyB,CAAC;IAgBrC;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACiB,qBAAqB,CACvC,EAAE,OAAO,EAAE,GAAG,OAAO,EAAE,EAAE,wBAAwB,GAChD,OAAO,CAAC,IAAI,CAAC;CAejB"}

package/dist/types/api/SessionRelations.d.ts

@@ -1,9 +1,118 @@
 import { GetSessionRelationsOptions, GetSessionRelationsResponse, CreateSessionRelationsOptions, CreateSessionRelationsResponse, DeleteSessionRelationsOptions } from '../types/session-relations';
 import { HITLBase } from './HITLBase';
+/**
+ * Manages relationships between HitL (Human-in-the-Loop) sessions
+ *
+ * This class provides functionality to:
+ * - Retrieve session relationships
+ * - Create new relationships between sessions
+ * - Remove existing relationships
+ *
+ * @remarks
+ * - All methods in this class interact with the `/session-relations` endpoint
+ * @public
+ */
 export declare class SessionRelations extends HITLBase {
     protected static MODULE_URL: string;
+    /**
+     * Retrieves a list of HitL session relations based on specified criteria
+     *
+     * @param options - Configuration parameters for retrieving HitL session relations
+     *
+     * Required parameters:
+     * - `sessionIds` - (string[]) Array of session IDs to retrieve relations for
+     *
+     * Optional parameters:
+     * - `relations` - (string[]) Array of specific relation types to retrieve
+     * - `skipSessions` - (boolean) Whether to skip retrieving session details
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<GetSessionRelationsResponse>} Promise resolving to session relationships
+     *
+     * @example
+     * ```typescript
+     * // Get all relations and sessions from this relations for specific sessions
+     * const relations = await hitlApi.sessionRelations.getSessionRelations({
+     *   sessionIds: ['session-id-1', 'session-id-2']
+     * });
+     *
+     * // Get specific relation types with session details skipped
+     * const relations = await hitlApi.sessionRelations.getSessionRelations({
+     *   sessionIds: ['session-id-1'],
+     *   relations: ['parent', 'child'],
+     *   skipSessions: true
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a GET request to the `/session-relations` endpoint
+     * @public
+     */
     static getSessionRelations(options: GetSessionRelationsOptions): Promise<GetSessionRelationsResponse>;
+    /**
+     * Creates new relations between HitL sessions
+     *
+     * @param options - Configuration parameters for creating session relations
+     *
+     * Required parameters:
+     * - `relations` - ({@link SessionRelation}[]) Array of session relation objects to create
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<SessionRelation[]>} Promise resolving to array of created session relations
+     *
+     * @example
+     * ```typescript
+     * const created = await hitlApi.sessionRelations.createSessionRelations({
+     *   relations: [{
+     *     aSessionId: 'session-id-1',
+     *     bSessionId: 'session-id-2',
+     *     relation: 'parent'
+     *   }, {
+     *     aSessionId: 'session-id-1',
+     *     bSessionId: 'session-id-3',
+     *     relation: 'parent'
+     *   }]
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a POST request to the `/session-relations` endpoint
+     * @public
+     */
     static createSessionRelations(options: CreateSessionRelationsOptions): Promise<CreateSessionRelationsResponse>;
+    /**
+     * Deletes specified HitL session relationships
+     *
+     * @param options - Configuration parameters for deleting relationships
+     *
+     * Required parameters:
+     * - `relations` - ({@link SessionRelation}[]) Array of session relation objects to delete
+     *
+     * Optional parameters:
+     * - `timeout` - (number) Request timeout in milliseconds
+     * - `version` - (string | number) API version to use
+     *
+     * @returns {Promise<void>} Promise that resolves when deletion is complete
+     *
+     * @example
+     * ```typescript
+     * await hitlApi.sessionRelations.deleteSessionRelations({
+     *   relations: [{
+     *     aSessionId: 'session-id-1',
+     *     bSessionId: 'session-id-2',
+     *     relation: 'parent'
+     *   }]
+     * });
+     * ```
+     *
+     * @remarks
+     * Makes a DELETE request to the `/session-relations` endpoint
+     * @public
+     */
     static deleteSessionRelations(options: DeleteSessionRelationsOptions): Promise<void>;
 }
 //# sourceMappingURL=SessionRelations.d.ts.map

package/dist/types/api/SessionRelations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SessionRelations.d.ts","sourceRoot":"","sources":["../../../src/api/SessionRelations.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AActC,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,SAAS,CAAC,MAAM,CAAC,UAAU,SAAuB;WAqCpC,mBAAmB,CAC/B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC;WA+CzB,sBAAsB,CAClC,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,8BAA8B,CAAC;WA2C5B,sBAAsB,CAClC,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,IAAI,CAAC;CAajB"}
+{"version":3,"file":"SessionRelations.d.ts","sourceRoot":"","sources":["../../../src/api/SessionRelations.ts"],"names":[],"mappings":"AACA,OAAO,EAGL,0BAA0B,EAC1B,2BAA2B,EAC3B,6BAA6B,EAC7B,8BAA8B,EAC9B,6BAA6B,EAC9B,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAEtC;;;;;;;;;;;GAWG;AACH,qBAAa,gBAAiB,SAAQ,QAAQ;IAC5C,SAAS,CAAC,MAAM,CAAC,UAAU,SAAuB;IAElD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAkCG;WACW,mBAAmB,CAC/B,OAAO,EAAE,0BAA0B,GAClC,OAAO,CAAC,2BAA2B,CAAC;IAcvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;WACW,sBAAsB,CAClC,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,8BAA8B,CAAC;IAc1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;WACW,sBAAsB,CAClC,OAAO,EAAE,6BAA6B,GACrC,OAAO,CAAC,IAAI,CAAC;CAajB"}