@intellegens/cornerstone-client 0.0.45 → 0.0.9999-alpha-2

package/services/api/ApiReadControllerClient/index.js

@@ -1,11 +1,6 @@
 import { apiInitializationService } from '../ApiInitializationService';
 /**
- * Generic API client for consuming any Cornerstone ReadController
- *
- * @export
- * @class ApiReadControllerClient
- * @template TKey - Type of the entity key (e.g., number, string, GUID, etc.)
- * @template TDto - Data Transfer Object representing the entity
+ * Base client for read-only API controllers
  */
 export class ApiReadControllerClient {
     baseControllerPath;
@@ -30,12 +25,13 @@ export class ApiReadControllerClient {
     // #region API
     /**
      * Fetches all entities from the read controller.
-     * @returns {Promise<ApiSuccessResponse<TDto[], ReadMetadata>>} List of all entities with metadata
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} List of all entities with metadata
      */
-    async readAll() {
+    async readAllAsync(signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadAll`);
-            const res = await this.httpService.request(url, { method: 'GET', credentials: 'include' });
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/ReadAll`);
+            const res = await this.httpService.requestAsync(url, { method: 'GET', credentials: 'include', signal });
             if (!res.ok)
                 throw undefined;
             const { success, result, metadata, error } = (await res.json());
@@ -51,16 +47,18 @@ export class ApiReadControllerClient {
     /**
      * Fetches selected entities based on a filter definition.
      * @param {any} definition - The filter definition object
-     * @returns {Promise<ApiSuccessResponse<TDto[], ReadMetadata>>} The result of the read operation with metadata
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto>[], ReadMetadataDto>>} The result of the read operation with metadata
      */
-    async readSelected(definition) {
+    async readSelectedAsync(definition, signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSelected`);
-            const res = await this.httpService.request(url, {
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/ReadSelected`);
+            const res = await this.httpService.requestAsync(url, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(definition),
                 credentials: 'include',
+                signal,
             });
             if (!res.ok)
                 throw undefined;
@@ -77,12 +75,13 @@ export class ApiReadControllerClient {
     /**
      * Fetches a single entity by its ID.
      * @param {TKey} id - The ID of the entity
-     * @returns {Promise<ApiSuccessResponse<TDto, EmptyMetadata>>} The requested entity
+     * @param {AbortSignal} [signal] - Optional cancellation signal
+     * @returns {Promise<ApiSuccessResponseDto<TDto, EmptyMetadataDto>>} The requested entity
      */
-    async readSingle(id) {
+    async readSingleAsync(id, signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/ReadSingle?id=${encodeURIComponent(String(id))}`);
-            const res = await this.httpService.request(url, { method: 'GET', credentials: 'include' });
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/ReadSingle?id=${encodeURIComponent(String(id))}`);
+            const res = await this.httpService.requestAsync(url, { method: 'GET', credentials: 'include', signal });
             if (!res.ok)
                 throw undefined;
             const { success, result, metadata, error } = (await res.json());

package/services/api/HttpService/FetchHttpService.d.ts

@@ -3,5 +3,5 @@ import { HttpRequestConfig, HttpResponse, IHttpService } from '../../../services
  * Default HTTP service implementation using the Fetch API
  */
 export declare class FetchHttpService implements IHttpService {
-    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    requestAsync<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
 }

package/services/api/HttpService/FetchHttpService.js

@@ -4,12 +4,13 @@
  * Default HTTP service implementation using the Fetch API
  */
 export class FetchHttpService {
-    async request(url, config) {
+    async requestAsync(url, config) {
         const response = await fetch(url, {
             method: config?.method || 'GET',
             headers: config?.headers,
             body: config?.body,
             credentials: config?.credentials || 'include',
+            signal: config?.signal,
         });
         // Convert Headers to a plain object
         const headers = {};

package/services/api/HttpService/HttpRequestConfig.d.ts

@@ -6,4 +6,5 @@ export interface HttpRequestConfig {
     headers?: Record<string, string>;
     body?: string;
     credentials?: RequestCredentials;
+    signal?: AbortSignal;
 }

package/services/api/HttpService/IHttpService.d.ts

@@ -9,5 +9,5 @@ export interface IHttpService {
      * @param config - Request configuration
      * @returns Promise that resolves to the HTTP response
      */
-    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
+    requestAsync<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
 }

package/services/api/HttpService/index.d.ts

@@ -3,8 +3,6 @@ import { FetchHttpService } from './FetchHttpService';
  * Default HTTP service instance
  */
 export declare const defaultHttpService: FetchHttpService;
-export * from './AxiosHttpService';
-export * from './AngularHttpService';
 export * from './FetchHttpService';
 export * from './HttpRequestConfig';
 export * from './HttpResponse';

package/services/api/HttpService/index.js

@@ -4,8 +4,6 @@ import { FetchHttpService } from './FetchHttpService';
  */
 export const defaultHttpService = new FetchHttpService();
 // Export additional HTTP service implementations
-export * from './AxiosHttpService';
-export * from './AngularHttpService';
 export * from './FetchHttpService';
 export * from './HttpRequestConfig';
 export * from './HttpResponse';

package/services/api/UserManagementControllerClient/index.d.ts

@@ -1,6 +1,6 @@
 import { ApiCrudControllerClient } from '../ApiCrudControllerClient';
 import { IHttpService } from '../HttpService';
-import { UserDto, ClaimDto, ReadMetadata, ApiSuccessResponse } from '../../../data';
+import { UserDto, ClaimDto, ReadMetadataDto, ApiSuccessResponseDto } from '../../../data';
 /**
  * Client for user management operations
  *
@@ -19,25 +19,29 @@ export declare class UserManagementControllerClient<TKey, TUser extends UserDto<
     /**
      * Gets the roles assigned to a user
      * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of role names assigned to the user
      */
-    getUserRoles(id: TKey): Promise<ApiSuccessResponse<string[], ReadMetadata>>;
+    getUserRolesAsync(id: TKey, signal?: AbortSignal): Promise<ApiSuccessResponseDto<string[], ReadMetadataDto>>;
     /**
      * Gets the claims assigned to a user
      * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of claims assigned to the user
      */
-    getUserClaims(id: TKey): Promise<ApiSuccessResponse<ClaimDto[], ReadMetadata>>;
+    getUserClaimsAsync(id: TKey, signal?: AbortSignal): Promise<ApiSuccessResponseDto<ClaimDto[], ReadMetadataDto>>;
     /**
      * Gets all available roles in the system
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of all role names
      */
-    getAllRoles(): Promise<ApiSuccessResponse<string[], ReadMetadata>>;
+    getAllRolesAsync(signal?: AbortSignal): Promise<ApiSuccessResponseDto<string[], ReadMetadataDto>>;
     /**
      * Changes the password for a user
      * @param id - The ID of the user
      * @param newPassword - The new password to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns Promise that resolves when the password is changed successfully
      */
-    changePassword(id: TKey, newPassword: string): Promise<void>;
+    changePasswordAsync(id: TKey, newPassword: string, signal?: AbortSignal): Promise<void>;
 }

package/services/api/UserManagementControllerClient/index.js

@@ -20,14 +20,16 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
     /**
      * Gets the roles assigned to a user
      * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of role names assigned to the user
      */
-    async getUserRoles(id) {
+    async getUserRolesAsync(id, signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetUserRoles', encodeURIComponent(String(id)));
-            const res = await this.httpService.request(url, {
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, 'GetUserRoles', encodeURIComponent(String(id)));
+            const res = await this.httpService.requestAsync(url, {
                 method: 'GET',
                 credentials: 'include',
+                signal,
             });
             if (!res.ok)
                 throw undefined;
@@ -44,14 +46,16 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
     /**
      * Gets the claims assigned to a user
      * @param id - The ID of the user
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of claims assigned to the user
      */
-    async getUserClaims(id) {
+    async getUserClaimsAsync(id, signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetUserClaims', encodeURIComponent(String(id)));
-            const res = await this.httpService.request(url, {
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, 'GetUserClaims', encodeURIComponent(String(id)));
+            const res = await this.httpService.requestAsync(url, {
                 method: 'GET',
                 credentials: 'include',
+                signal,
             });
             if (!res.ok)
                 throw undefined;
@@ -67,14 +71,16 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
     }
     /**
      * Gets all available roles in the system
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns List of all role names
      */
-    async getAllRoles() {
+    async getAllRolesAsync(signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'GetAllRoles');
-            const res = await this.httpService.request(url, {
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, 'GetAllRoles');
+            const res = await this.httpService.requestAsync(url, {
                 method: 'GET',
                 credentials: 'include',
+                signal,
             });
             if (!res.ok)
                 throw undefined;
@@ -92,18 +98,20 @@ export class UserManagementControllerClient extends ApiCrudControllerClient {
      * Changes the password for a user
      * @param id - The ID of the user
      * @param newPassword - The new password to set
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @returns Promise that resolves when the password is changed successfully
      */
-    async changePassword(id, newPassword) {
+    async changePasswordAsync(id, newPassword, signal) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, 'ChangePassword', encodeURIComponent(String(id)));
-            const response = await this.httpService.request(url, {
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, 'ChangePassword', encodeURIComponent(String(id)));
+            const response = await this.httpService.requestAsync(url, {
                 method: 'POST',
                 headers: {
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify(newPassword),
                 credentials: 'include',
+                signal,
             });
             if (!response.ok)
                 throw undefined;

package/services/auth/client/AuthService/index.d.ts

@@ -1,4 +1,4 @@
-import { ApiSuccessResponse, EmptyMetadata, UserDto, UserInfoDto } from '../../../../data';
+import { ApiSuccessResponseDto, EmptyMetadataDto, UserDto, UserInfoDto } from '../../../../data';
 export { UserDto, UserInfoDto };
 /**
  * AuthService class is responsible for managing user authentication operations.
@@ -18,14 +18,14 @@ export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKe
      * @async
      * @return {Promise<void>} Resolves when initialization is complete.
      */
-    initialize(): Promise<void>;
+    initializeAsync(): Promise<void>;
     /**
      * Checks if user is authenticated and retrieves the current user's details if they are
      *
      * @return {Promise<UserInfoDto<TKey, TUser>>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    whoAmI(): Promise<ApiSuccessResponse<UserInfoDto<TKey, TUser> | undefined, EmptyMetadata>>;
+    whoAmIAsync(): Promise<ApiSuccessResponseDto<UserInfoDto<TKey, TUser> | undefined, EmptyMetadataDto>>;
     /**
      * Authenticates a user using their username and password, and retrieves user's details
      *
@@ -34,14 +34,14 @@ export declare class AuthService<TKey, TUser extends UserDto<TKey> = UserDto<TKe
      * @return {Promise<TUser>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    signin(username: string, password: string): Promise<ApiSuccessResponse<TUser, EmptyMetadata>>;
+    signinAsync(username: string, password: string): Promise<ApiSuccessResponseDto<TUser, EmptyMetadataDto>>;
     /**
      * Deauthenticates current user
      *
      * @return {Promise<void>}
      * @throws {Error} Error if fetch fails
      */
-    signout(): Promise<void>;
+    signoutAsync(): Promise<void>;
     /**
      * If any API response returns an "Unauthenticated" response, call this method
      * to update local authentication state to unauthenticated

package/services/auth/client/AuthService/index.js

@@ -17,9 +17,9 @@ export class AuthService {
      * @async
      * @return {Promise<void>} Resolves when initialization is complete.
      */
-    async initialize() {
+    async initializeAsync() {
         // Check user's authentication status
-        await this.whoAmI();
+        await this.whoAmIAsync();
     }
     /**
      * Checks if user is authenticated and retrieves the current user's details if they are
@@ -27,9 +27,9 @@ export class AuthService {
      * @return {Promise<UserInfoDto<TKey, TUser>>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    async whoAmI() {
+    async whoAmIAsync() {
         try {
-            const url = await apiInitializationService.getApiUrl('/auth/whoami');
+            const url = await apiInitializationService.getApiUrlAsync('/auth/whoami');
             const res = await fetch(url, { credentials: 'include' });
             if (!res.ok && res.status !== 401) {
                 this.user = undefined;
@@ -58,9 +58,9 @@ export class AuthService {
      * @return {Promise<TUser>} Currently logged in user's details
      * @throws {Error} Error if fetch fails
      */
-    async signin(username, password) {
+    async signinAsync(username, password) {
         try {
-            const url = await apiInitializationService.getApiUrl('/auth/signin');
+            const url = await apiInitializationService.getApiUrlAsync('/auth/signin');
             const res = await fetch(url, {
                 method: 'POST',
                 headers: { 'Content-Type': 'application/json' },
@@ -70,7 +70,7 @@ export class AuthService {
             if (!res.ok)
                 throw undefined;
             // TODO: Handle tokens if not using cookies
-            const { result, metadata } = await this.whoAmI();
+            const { result, metadata } = await this.whoAmIAsync();
             if (result === undefined)
                 throw undefined;
             this.user = result.user;
@@ -87,9 +87,9 @@ export class AuthService {
      * @return {Promise<void>}
      * @throws {Error} Error if fetch fails
      */
-    async signout() {
+    async signoutAsync() {
         try {
-            const url = await apiInitializationService.getApiUrl('/auth/signout');
+            const url = await apiInitializationService.getApiUrlAsync('/auth/signout');
             const res = await fetch(url, { credentials: 'include' });
             if (!res.ok)
                 throw undefined;

package/services/auth/client/AuthorizationManagementControllerClient/index.d.ts

@@ -1,4 +1,4 @@
-import { ApiSuccessResponse, EmptyMetadata, ReadMetadata, RoleDto } from '../../../../data';
+import { ApiSuccessResponseDto, EmptyMetadataDto, ReadMetadataDto, RoleDto } from '../../../../data';
 /**
  * Client for authorization management operations
  *
@@ -17,23 +17,23 @@ export declare class AuthorizationManagementControllerClient {
      * @param includeClaims - Whether to include claims in the response
      * @returns List of all roles
      */
-    getAllRoles(includeClaims: boolean): Promise<ApiSuccessResponse<RoleDto[], ReadMetadata>>;
+    getAllRolesAsync(includeClaims: boolean): Promise<ApiSuccessResponseDto<RoleDto[], ReadMetadataDto>>;
     /**
      * Gets a role with its claims
      * @param roleName - The name of the role
      * @returns The role with its claims
      */
-    getRoleWithClaims(roleName: string): Promise<ApiSuccessResponse<RoleDto, ReadMetadata>>;
+    getRoleWithClaimsAsync(roleName: string): Promise<ApiSuccessResponseDto<RoleDto, ReadMetadataDto>>;
     /**
      * Creates or updates a role
      * @param roleDto - The role to create or update
      * @returns The created or updated role
      */
-    upsertRole(roleDto: RoleDto): Promise<ApiSuccessResponse<RoleDto, EmptyMetadata>>;
+    upsertRoleAsync(roleDto: RoleDto): Promise<ApiSuccessResponseDto<RoleDto, EmptyMetadataDto>>;
     /**
      * Deletes a role
      * @param roleName - The name of the role to delete
      * @returns Promise that resolves when the role is deleted successfully
      */
-    deleteRole(roleName: string): Promise<void>;
+    deleteRoleAsync(roleName: string): Promise<void>;
 }

package/services/auth/client/AuthorizationManagementControllerClient/index.js

@@ -19,9 +19,9 @@ export class AuthorizationManagementControllerClient {
      * @param includeClaims - Whether to include claims in the response
      * @returns List of all roles
      */
-    async getAllRoles(includeClaims) {
+    async getAllRolesAsync(includeClaims) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/GetAllRoles?includeClaims=${includeClaims}`);
             const res = await fetch(url, {
                 credentials: 'include',
             });
@@ -42,9 +42,9 @@ export class AuthorizationManagementControllerClient {
      * @param roleName - The name of the role
      * @returns The role with its claims
      */
-    async getRoleWithClaims(roleName) {
+    async getRoleWithClaimsAsync(roleName) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/GetRoleWithClaims/${encodeURIComponent(roleName)}`);
             const res = await fetch(url, {
                 credentials: 'include',
             });
@@ -65,9 +65,9 @@ export class AuthorizationManagementControllerClient {
      * @param roleDto - The role to create or update
      * @returns The created or updated role
      */
-    async upsertRole(roleDto) {
+    async upsertRoleAsync(roleDto) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/UpsertRole`);
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/UpsertRole`);
             const res = await fetch(url, {
                 method: 'PUT',
                 headers: {
@@ -93,9 +93,9 @@ export class AuthorizationManagementControllerClient {
      * @param roleName - The name of the role to delete
      * @returns Promise that resolves when the role is deleted successfully
      */
-    async deleteRole(roleName) {
+    async deleteRoleAsync(roleName) {
         try {
-            const url = await apiInitializationService.getApiUrl(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
+            const url = await apiInitializationService.getApiUrlAsync(this.baseControllerPath, `/DeleteRole/${encodeURIComponent(roleName)}`);
             const response = await fetch(url, {
                 method: 'DELETE',
                 credentials: 'include',

package/utils/index.d.ts

@@ -0,0 +1,37 @@
+import { PropertyPathDto, ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, ReadSelectedSearchDefinitionDto } from '../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all `ReadSelectedSearchPropertyDefinitionDto` property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - path: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export declare function condition(logicalOperator: ReadSelectedLogicalOperator, ...conditions: Array<{
+    path: PropertyPathDto;
+    operator: ReadSelectedComparisonOperator;
+    value: any;
+    valueType: ReadSelectedPropertyType;
+}>): ReadSelectedSearchDefinitionDto;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export declare function and(...definitions: ReadSelectedSearchDefinitionDto[]): ReadSelectedSearchDefinitionDto;
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export declare function or(...definitions: ReadSelectedSearchDefinitionDto[]): ReadSelectedSearchDefinitionDto;
+/**
+ * Preset implementation for filtering by `searchTerm`. String types will search by provided `textSearchablePaths` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchablePaths`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export declare function searchTerm(searchTerm: string, textSearchablePaths: string[][], numericSearchablePaths: string[][]): void | ReadSelectedSearchDefinitionDto;
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchablePath`.
+ */
+export declare function dateInterval(fromDate: Date, toDate: Date, fromDateComparisonOperator: ReadSelectedComparisonOperator, toDateComparisonOperator: ReadSelectedComparisonOperator, valueType: ReadSelectedPropertyType, searchablePath: PropertyPathDto): void | ReadSelectedSearchDefinitionDto;
+/**
+ * Converts the camel case used on the TS client to Pascal case expected by the API
+ */
+export declare function toPascalCase(str: PropertyPathDto): PropertyPathDto;

package/utils/index.js

@@ -0,0 +1,106 @@
+import { ReadSelectedComparisonOperator, ReadSelectedLogicalOperator, ReadSelectedPropertyType, } from '../data';
+/**
+ * Creates a ReadSelectedSearchDefinitionDto ready to be used with the CollectionViewAdapter
+ *
+ * @param logicalOperator - specify `ReadSelectedLogicalOperator` that will apply to all `ReadSelectedSearchPropertyDefinitionDto` property definitions included in this search definition
+ * @param conditions - Variable number of condition objects containing:
+ *   - path: The property name from the DTO to search on
+ *   - operator: The `ReadSelectedComparisonOperator` enum
+ *   - value: The value to compare against
+ *   - valueType: The `ReadSelectedPropertyType` being compared
+ */
+export function condition(logicalOperator, ...conditions) {
+    return {
+        logicalOperator: logicalOperator,
+        propertyCriteria: conditions.map(condition => ({
+            propertyPath: toPascalCase(condition.path),
+            comparisonOperator: condition.operator,
+            valueType: condition.valueType,
+            value: condition.value,
+        })),
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with AND logic
+ */
+export function and(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.And,
+        nestedSearchCriteria: definitions,
+    };
+}
+/**
+ * Combines multiple ReadSelectedSearchDefinitionDto with OR logic
+ */
+export function or(...definitions) {
+    return {
+        logicalOperator: ReadSelectedLogicalOperator.Or,
+        nestedSearchCriteria: definitions,
+    };
+}
+/**
+ * Preset implementation for filtering by `searchTerm`. String types will search by provided `textSearchablePaths` with `ReadSelectedComparisonOperator.Contains`. Numeric types will search by provided `numericSearchablePaths`, `parseInt` the search term and use `ReadSelectedComparisonOperator.Equal`.
+ */
+export function searchTerm(searchTerm, textSearchablePaths, numericSearchablePaths) {
+    let comparisonOperator;
+    let valueType;
+    let searchablePaths;
+    let searchValue;
+    try {
+        const numericValue = parseInt(searchTerm);
+        if (!Number.isNaN(numericValue) && String(numericValue) === searchTerm.trim()) {
+            comparisonOperator = ReadSelectedComparisonOperator.Equal;
+            valueType = ReadSelectedPropertyType.Int;
+            searchablePaths = numericSearchablePaths;
+            searchValue = numericValue;
+        }
+        else {
+            comparisonOperator = ReadSelectedComparisonOperator.Contains;
+            valueType = ReadSelectedPropertyType.String;
+            searchablePaths = textSearchablePaths;
+            searchValue = searchTerm;
+        }
+        const searchConditions = searchablePaths.map(path => ({
+            path: toPascalCase(path),
+            operator: comparisonOperator,
+            value: searchValue,
+            valueType: valueType,
+        }));
+        return condition(ReadSelectedLogicalOperator.Or, ...searchConditions);
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * Preset implementation for filtering a date range. User may select desired `ReadSelectedComparisonOperator` and `ReadSelectedPropertyType` for the from and to dates. Valid object property must be provided for `searchablePath`.
+ */
+export function dateInterval(fromDate, toDate, fromDateComparisonOperator, toDateComparisonOperator, valueType, searchablePath) {
+    try {
+        if (!(valueType === ReadSelectedPropertyType.DateOnly ||
+            valueType === ReadSelectedPropertyType.DateTime ||
+            valueType === ReadSelectedPropertyType.DateTimeOffset)) {
+            return;
+        }
+        return condition(ReadSelectedLogicalOperator.And, {
+            path: toPascalCase(searchablePath),
+            operator: fromDateComparisonOperator,
+            value: fromDate,
+            valueType: valueType,
+        }, {
+            path: toPascalCase(searchablePath),
+            operator: toDateComparisonOperator,
+            value: toDate,
+            valueType: valueType,
+        });
+    }
+    catch {
+        return;
+    }
+}
+/**
+ * Converts the camel case used on the TS client to Pascal case expected by the API
+ */
+export function toPascalCase(str) {
+    return str.map(part => part.charAt(0).toUpperCase() + part.slice(1));
+}

package/data/api/dto/response/EmptyMetadata.d.ts

@@ -1,4 +0,0 @@
-/**
- * Default, empty metadata.
- */
-export type EmptyMetadata = object;

package/services/api/HttpService/AngularHttpService.d.ts

@@ -1,9 +0,0 @@
-import { IHttpService, HttpRequestConfig, HttpResponse } from './index';
-/**
- * Angular HttpClient-based HTTP service implementation
- */
-export declare class AngularHttpService implements IHttpService {
-    private httpClient;
-    constructor(httpClient: any);
-    request<T = any>(url: string, config?: HttpRequestConfig): Promise<HttpResponse<T>>;
-}