@intellegens/cornerstone-client 0.0.44 → 0.0.9999-alpha-1

package/services/api/ApiInitializationService/index.js

@@ -11,17 +11,21 @@ export class ApiInitializationService {
      *
      * This method calls all methods that need to be called during the API configuration phase:
      * - Starts detection of API base URL.
+     * - Fetches shared settings from the server.
      *
      * @async
      * @param httpService - HTTP service implementation to use for requests
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @return {Promise<void>} Resolves when initialization is complete.
      */
-    async initialize({ httpService } = {}) {
+    async initializeAsync({ httpService, signal } = {}) {
         // Store configuration
         if (httpService !== undefined)
             this._httpService = httpService;
         // (Pre)detect API base URL
-        await this._getApiBaseUrl();
+        await this._getApiBaseUrlAsync(signal);
+        // Initialize app config
+        await this._getAppConfigAsync();
     }
     // #region HTTP service
     _httpService = defaultHttpService;
@@ -65,10 +69,11 @@ export class ApiInitializationService {
      * IMPORTANT: This method is not meant to be used in normal cases - when ever possible use the .getApiUrl(relativeEndpointPath: string) method instead.
      *
      * @async
+     * @param {AbortSignal} [signal] - Optional cancellation signal
      * @return {Promise<string | undefined>} Returns detected API base URL
      * @throws {Error} Throws error if either of the detection methods fails
      */
-    async _getApiBaseUrl() {
+    async _getApiBaseUrlAsync(signal) {
         // Check if API already detected; don't reattempt detection
         if (this._apiBaseUrlDetected)
             return this._apiBaseUrl;
@@ -84,7 +89,7 @@ export class ApiInitializationService {
             this._apiBaseError = undefined;
             // Check CORNERSTONE-API-BASEURL header for API base URL
             try {
-                const currentUrlResponse = await this._httpService.request(window.location.href, { method: 'GET' });
+                const currentUrlResponse = await this._httpService.requestAsync(window.location.href, { method: 'GET', signal });
                 const apiHeader = currentUrlResponse.headers['CORNERSTONE-API-BASEURL'] || currentUrlResponse.headers['cornerstone-api-baseurl'] || null;
                 if (apiHeader) {
                     this._apiBaseUrlDetected = true;
@@ -100,7 +105,7 @@ export class ApiInitializationService {
             }
             // Check ./websettings.json header for API base URL
             try {
-                const webSettingsResponse = await this._httpService.request('./websettings.json', { method: 'GET' });
+                const webSettingsResponse = await this._httpService.requestAsync('./websettings.json', { method: 'GET', signal });
                 if (webSettingsResponse.status === 404)
                     return (this._apiBaseUrl = undefined);
                 const webSettings = await webSettingsResponse.json();
@@ -141,8 +146,8 @@ export class ApiInitializationService {
      * @return {Promise<string | undefined>} Returns the API endpoint's URL
      * @throws {Error} Throws error if API base URL detection fails
      */
-    async getApiUrl(...relativeEndpointPathSections) {
-        const apiBaseUrl = await this._getApiBaseUrl();
+    async getApiUrlAsync(...relativeEndpointPathSections) {
+        const apiBaseUrl = await this._getApiBaseUrlAsync();
         const domain = !apiBaseUrl ? '/' : `${this.removeEndsWithSlashChar(apiBaseUrl)}/`;
         const path = relativeEndpointPathSections.map(section => this.removeStartsWithSlashChar(this.removeEndsWithSlashChar(section))).join('/');
         return `${domain}${path}`;
@@ -163,6 +168,30 @@ export class ApiInitializationService {
     removeEndsWithSlashChar(str) {
         return !str.endsWith('/') ? str : str.substring(0, str.length - 1);
     }
+    // #endregion
+    // #region config App
+    appConfig;
+    /**
+    * Fetches initialization info (shared settings) from the server
+    * @returns Promise that resolves to shared settings or undefined if the request fails
+    */
+    async _getAppConfigAsync() {
+        try {
+            const response = await fetch(`${this._apiBaseUrl}/api/system/init`, { credentials: 'include' });
+            if (!response.ok)
+                throw new Error('Failed to get app config');
+            const apiResponse = await response.json();
+            // Check if the API response indicates success
+            if (!apiResponse.success || !apiResponse.result) {
+                throw new Error(apiResponse.error?.message || 'Server returned unsuccessful response');
+            }
+            // Return the settings from the nested structure
+            this.appConfig = apiResponse.result.settings;
+        }
+        catch (error) {
+            this.appConfig = undefined;
+        }
+    }
 }
 /**
  * Singleton instance of ApiInitializationService

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

@@ -1,12 +1,8 @@
-import { IIdentifiable, ApiSuccessResponse, ReadSelectedDefinitionDto, ReadMetadata, EmptyMetadata } from '../../../data';
+import { ApiSuccessResponseDto, EmptyMetadataDto, ReadMetadataDto, ReadSelectedDefinitionDto } from '../../../data/api/dto';
+import { IIdentifiable } from '../../../data/api/interface';
 import { IHttpService } from '../HttpService';
 /**
- * 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 declare class ApiReadControllerClient<TKey, TDto extends IIdentifiable<TKey>> {
     protected readonly baseControllerPath: string;
@@ -23,19 +19,22 @@ export declare class ApiReadControllerClient<TKey, TDto extends IIdentifiable<TK
     protected get httpService(): IHttpService;
     /**
      * 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
      */
-    readAll(): Promise<ApiSuccessResponse<TDto[], ReadMetadata>>;
+    readAllAsync(signal?: AbortSignal): Promise<ApiSuccessResponseDto<TDto[], ReadMetadataDto>>;
     /**
      * 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
      */
-    readSelected(definition: ReadSelectedDefinitionDto): Promise<ApiSuccessResponse<TDto[], ReadMetadata>>;
+    readSelectedAsync(definition: ReadSelectedDefinitionDto, signal?: AbortSignal): Promise<ApiSuccessResponseDto<TDto[], ReadMetadataDto>>;
     /**
      * 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
      */
-    readSingle(id: TKey): Promise<ApiSuccessResponse<TDto, EmptyMetadata>>;
+    readSingleAsync(id: TKey, signal?: AbortSignal): Promise<ApiSuccessResponseDto<TDto, EmptyMetadataDto>>;
 }

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',