tm1npm 1.5.3 → 2.0.0

package/lib/services/ProcessService.js

@@ -180,7 +180,7 @@ class ProcessService extends ObjectService_1.ObjectService {
         }
         const config = {};
         if (timeout) {
-            config.timeout = timeout * 1000;
+            config.timeout = timeout;
         }
         return await this.rest.post(url, JSON.stringify(body), config);
     }
@@ -193,93 +193,54 @@ class ProcessService extends ObjectService_1.ObjectService {
         const url = (0, Utils_1.formatUrl)("/Processes('{}')/tm1.Compile", processName);
         return await this.rest.post(url, '{}');
     }
-    async compileProcess(processName) {
-        var _a, _b, _c;
-        /** Compile a process and return detailed compilation results
+    async compileProcess(process) {
+        /** Compile an unbound process and return syntax errors
          *
-         * :param process_name: name of the process
-         * :return: compilation result with success status and error details
+         * :param process: Instance of .Process class
+         * :return: list of syntax errors (empty if successful)
          */
-        try {
-            const response = await this.compile(processName);
-            // Check if compilation was successful
-            if (response.status === 200) {
-                return {
-                    success: true,
-                    errors: []
-                };
-            }
-            else {
-                return {
-                    success: false,
-                    errors: [response.statusText || 'Compilation failed']
-                };
-            }
-        }
-        catch (error) {
-            const errorMessage = ((_c = (_b = (_a = error.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) || error.message || 'Unknown compilation error';
-            return {
-                success: false,
-                errors: [errorMessage]
-            };
-        }
+        const url = '/CompileProcess';
+        const payload = { Process: process.bodyAsDict };
+        const response = await this.rest.post(url, JSON.stringify(payload));
+        return response.data.value;
     }
     /**
-     * Poll execution status for async process execution
+     * Poll for async execution result
+     *
+     * :param asyncId: async operation ID returned from executeWithReturn with returnAsyncId=true
+     * :return: tuple of [success, status, errorLogFile] or null if not ready
      */
-    async pollExecuteWithReturn(processName, parameters, timeout = 300, pollInterval = 5) {
-        /** Execute process asynchronously and poll for completion
-         *
-         * :param process_name: name of the process
-         * :param parameters: dictionary of process parameters
-         * :param timeout: maximum time to wait for completion (seconds)
-         * :param poll_interval: time between status checks (seconds)
-         * :return: execution result when completed
-         */
-        // Start async execution
-        const executeUrl = (0, Utils_1.formatUrl)("/Processes('{}')/tm1.ExecuteAsync", processName);
-        const body = {};
-        if (parameters && Object.keys(parameters).length > 0) {
-            body.Parameters = Object.entries(parameters).map(([name, value]) => ({
-                Name: name,
-                Value: value
-            }));
-        }
-        const executeResponse = await this.rest.post(executeUrl, JSON.stringify(body));
-        const executionId = executeResponse.data.ID || executeResponse.data.ExecutionId;
-        if (!executionId) {
-            throw new TM1Exception_1.TM1Exception('Failed to start async process execution');
-        }
-        // Poll for completion
-        const startTime = Date.now();
-        const maxTime = timeout * 1000;
-        while (Date.now() - startTime < maxTime) {
-            try {
-                // Check execution status
-                const statusUrl = `/ExecutionStatus('${executionId}')`;
-                const statusResponse = await this.rest.get(statusUrl);
-                const status = statusResponse.data;
-                if (status.Status === 'Completed') {
-                    // Get execution results
-                    const resultUrl = `/ExecutionResults('${executionId}')`;
-                    const resultResponse = await this.rest.get(resultUrl);
-                    return resultResponse.data;
-                }
-                else if (status.Status === 'Failed') {
-                    throw new TM1Exception_1.TM1Exception(`Process execution failed: ${status.ErrorMessage || 'Unknown error'}`);
-                }
-                // Wait before next poll
-                await new Promise(resolve => setTimeout(resolve, pollInterval * 1000));
+    async pollExecuteWithReturn(asyncId) {
+        var _a, _b;
+        try {
+            const response = await this.rest.retrieve_async_response(asyncId);
+            // tm1py returns None while the async op is still in-flight (status 202).
+            if (response.status !== 200 && response.status !== 201) {
+                return null;
             }
-            catch (error) {
-                if (error instanceof TM1Exception_1.TM1Exception) {
-                    throw error;
-                }
-                // If status check fails, wait and retry
-                await new Promise(resolve => setTimeout(resolve, pollInterval * 1000));
+            // TODO: tm1py handles TM1 < v11 binary-wrapped responses via
+            // build_response_from_binary_response. Add support if needed.
+            return this._executeWithReturnParseResponse(response.data);
+        }
+        catch (error) {
+            // 404 means the async resource hasn't materialized yet — return null
+            // so the caller can retry. 202 means still running. Both are
+            // retryable, unlike AsyncOperationService which treats 404 as
+            // terminal FAILED for locally-tracked operations.
+            const err = error;
+            const status = (_a = err === null || err === void 0 ? void 0 : err.status) !== null && _a !== void 0 ? _a : (_b = err === null || err === void 0 ? void 0 : err.response) === null || _b === void 0 ? void 0 : _b.status;
+            if (status === 202 || status === 404) {
+                return null;
             }
+            throw error;
         }
-        throw new TM1Exception_1.TM1Exception(`Process execution timed out after ${timeout} seconds`);
+    }
+    _executeWithReturnParseResponse(executionSummary) {
+        var _a, _b;
+        const success = executionSummary.ProcessExecuteStatusCode === 'CompletedSuccessfully';
+        const status = executionSummary.ProcessExecuteStatusCode;
+        const errorLogFile = (_b = (_a = executionSummary.ErrorLogFile) === null || _a === void 0 ? void 0 : _a.Filename) !== null && _b !== void 0 ? _b : null;
+        return [success, status, errorLogFile];
     }
     async executeProcessWithReturn(processName, parameters) {
         /** Execute process with return values
@@ -301,7 +262,7 @@ class ProcessService extends ObjectService_1.ObjectService {
         // For now, return empty string
         return '';
     }
-    async getProcessDebugBreakpoints(debugId) {
+    async debugGetBreakpoints(debugId) {
         /** Get debug breakpoints for a debug context
          *
          * :param debugId: debug session ID
@@ -311,18 +272,17 @@ class ProcessService extends ObjectService_1.ObjectService {
         const response = await this.rest.get(url);
         return response.data.value.map((bp) => ProcessDebugBreakpoint_1.ProcessDebugBreakpoint.fromDict(bp));
     }
-    async createProcessDebugBreakpoint(debugId, breakpoint) {
-        /** Create a debug breakpoint in a debug context
+    async debugAddBreakpoint(debugId, breakpoint) {
+        /** Add a single breakpoint to a debug context (delegates to debugAddBreakpoints)
          *
          * :param debugId: debug session ID
          * :param breakpoint: ProcessDebugBreakpoint object
          * :return: response
          */
-        const url = (0, Utils_1.formatUrl)("/ProcessDebugContexts('{}')/Breakpoints", debugId);
-        return await this.rest.post(url, breakpoint.body);
+        return this.debugAddBreakpoints(debugId, [breakpoint]);
     }
-    async deleteProcessDebugBreakpoint(debugId, breakpointId) {
-        /** Delete a debug breakpoint from a debug context
+    async debugRemoveBreakpoint(debugId, breakpointId) {
+        /** Remove a breakpoint from a debug context
          *
          * :param debugId: debug session ID
          * :param breakpointId: ID of the breakpoint
@@ -584,9 +544,11 @@ class ProcessService extends ObjectService_1.ObjectService {
         }
         const config = {};
         if (timeout) {
-            config.timeout = timeout * 1000;
+            config.timeout = timeout;
         }
-        const response = await this.rest.post(url, JSON.stringify(body), config);
+        // rest.post returns AxiosResponse | string (string only when caller
+        // opts into returnAsyncId). debugProcess never does, so narrow.
+        const response = (await this.rest.post(url, JSON.stringify(body), config));
         return response.data;
     }
     /**
@@ -676,6 +638,53 @@ class ProcessService extends ObjectService_1.ObjectService {
             throw new TM1Exception_1.TM1Exception(`Unexpected TI return status: '${status}' for expression: '${expression}'`);
         }
     }
+    /**
+     * Evaluate a TI expression and return the string result.
+     *
+     * Creates a temporary process with sFunc = {formula}, compiles it,
+     * starts a debug session, adds a data breakpoint on sFunc, continues
+     * execution to evaluate, reads the result, and cleans up.
+     */
+    async evaluateTiExpression(formula) {
+        // tm1py uses formula[formula.find("=") + 1:] which greedily strips at the
+        // first "=" anywhere in the string. We use a regex to only strip a leading
+        // "=" prefix (e.g. "=NOW;" → "NOW;"), avoiding mangling formulas with
+        // embedded "=" (e.g. comparisons like "IF(1=1,...)").
+        formula = formula.replace(/^\s*=\s*/, '');
+        // Ensure semicolon at end
+        if (!formula.trim().endsWith(';')) {
+            formula += ';';
+        }
+        const prologList = [`sFunc = ${formula}`, "sDebug='Stop';"];
+        const processName = `}TM1py${(0, uuid_1.v4)()}`;
+        const p = new Process_1.Process(processName, false, undefined, undefined, undefined, undefined, Process_1.Process.AUTO_GENERATED_STATEMENTS + prologList.join('\r\n'), '', '', '');
+        const syntaxErrors = await this.compileProcess(p);
+        if (syntaxErrors && syntaxErrors.length > 0) {
+            throw new Error(syntaxErrors.map(e => `Line ${e.LineNumber}: ${e.Message}`).join('; '));
+        }
+        try {
+            await this.create(p);
+            const debugContext = await this.debugProcess(processName);
+            const debugId = debugContext.ID;
+            const breakpoint = new ProcessDebugBreakpoint_1.ProcessDebugBreakpoint(1, ProcessDebugBreakpoint_1.BreakPointType.PROCESS_DEBUG_CONTEXT_DATA_BREAK_POINT, true, ProcessDebugBreakpoint_1.HitMode.BREAK_ALWAYS, 0, '', 'sFunc');
+            await this.debugAddBreakpoint(debugId, breakpoint);
+            await this.debugContinue(debugId);
+            const result = await this.debugGetVariableValues(debugId);
+            await this.debugContinue(debugId);
+            if (!result || !('sFunc' in result)) {
+                throw new Error('unknown error: no formula result found');
+            }
+            return result['sFunc'];
+        }
+        finally {
+            try {
+                await this.delete(processName);
+            }
+            catch (_) {
+                // Cleanup failure should not mask the original error
+            }
+        }
+    }
     /**
      * Analyze process dependencies (what cubes/dimensions/processes it uses)
      *
@@ -685,8 +694,8 @@ class ProcessService extends ObjectService_1.ObjectService {
      * @example
      * ```typescript
      * const deps = await processService.analyzeProcessDependencies('ImportData');
-     * console.log('Cubes used:', deps.cubes);
-     * console.log('Dimensions used:', deps.dimensions);
+     * // deps.cubes      => array of cube names referenced in the process
+     * // deps.dimensions => array of dimension names referenced in the process
      * ```
      */
     async analyzeProcessDependencies(processName) {
@@ -747,36 +756,34 @@ class ProcessService extends ObjectService_1.ObjectService {
      * Validate process syntax without executing it
      *
      * @param processName - Name of the process
-     * @returns Promise<{isValid: boolean, errors: any[]}> - Validation result
+     * @returns Promise<ValidationResult> - Validation result
      *
      * @example
      * ```typescript
      * const result = await processService.validateProcessSyntax('MyProcess');
      * if (!result.isValid) {
-     *     console.error('Errors:', result.errors);
+     *     // result.errors contains ValidationError[] entries
      * }
      * ```
      */
     async validateProcessSyntax(processName) {
+        var _a, _b, _c;
         try {
-            const result = await this.compileProcess(processName);
+            const response = await this.compile(processName);
+            if (response.status === 200) {
+                return { isValid: true, errors: [] };
+            }
             return {
-                isValid: result.success,
-                errors: result.errors.map((error, index) => ({
-                    line: index + 1,
-                    message: error,
-                    severity: 'Error'
-                }))
+                isValid: false,
+                errors: [{ line: 0, message: response.statusText || 'Compilation failed', severity: 'Error' }]
             };
         }
         catch (error) {
+            const err = error;
+            const errorMessage = ((_c = (_b = (_a = err.response) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b.error) === null || _c === void 0 ? void 0 : _c.message) || err.message || 'Validation failed';
             return {
                 isValid: false,
-                errors: [{
-                        line: 0,
-                        message: error.message || 'Validation failed',
-                        severity: 'Error'
-                    }]
+                errors: [{ line: 0, message: errorMessage, severity: 'Error' }]
             };
         }
     }
@@ -789,7 +796,7 @@ class ProcessService extends ObjectService_1.ObjectService {
      * @example
      * ```typescript
      * const plan = await processService.getProcessExecutionPlan('ImportData');
-     * console.log('Estimated execution time:', plan.estimatedTime);
+     * // plan.estimatedTime => estimated execution time (ms)
      * ```
      */
     async getProcessExecutionPlan(processName) {
@@ -864,7 +871,9 @@ class ProcessService extends ObjectService_1.ObjectService {
             asyncOps.updateOperationStatus(operationId, AsyncOperationService_1.OperationStatus.COMPLETED, result);
         })
             .catch((error) => {
-            asyncOps.updateOperationStatus(operationId, AsyncOperationService_1.OperationStatus.FAILED, undefined, error.message || String(error));
+            var _a;
+            const message = (_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : String(error);
+            asyncOps.updateOperationStatus(operationId, AsyncOperationService_1.OperationStatus.FAILED, undefined, message);
         });
         return operationId;
     }
@@ -877,9 +886,7 @@ class ProcessService extends ObjectService_1.ObjectService {
      * @example
      * ```typescript
      * const status = await processService.pollProcessExecution(operationId);
-     * if (status === OperationStatus.COMPLETED) {
-     *     console.log('Process completed!');
-     * }
+     * // if (status === OperationStatus.COMPLETED) handle completion
      * ```
      */
     async pollProcessExecution(operationId) {
@@ -898,7 +905,7 @@ class ProcessService extends ObjectService_1.ObjectService {
      * @example
      * ```typescript
      * await processService.cancelProcessExecution(operationId);
-     * console.log('Process execution cancelled');
+     * // cancellation is acknowledged once the promise resolves
      * ```
      */
     async cancelProcessExecution(operationId) {

package/lib/services/RestService.d.ts

@@ -1,4 +1,5 @@
 import { AxiosResponse, AxiosRequestConfig } from 'axios';
+import * as https from 'https';
 export declare enum AuthenticationMode {
     BASIC = 1,
     WIA = 2,
@@ -25,6 +26,9 @@ export interface RestServiceConfig {
     timeout?: number;
     cancelAtTimeout?: boolean;
     asyncRequestsMode?: boolean;
+    asyncPollingInitialDelay?: number;
+    asyncPollingMaxDelay?: number;
+    asyncPollingBackoffFactor?: number;
     connectionPoolSize?: number;
     poolConnections?: number;
     instance?: string;
@@ -36,21 +40,95 @@ export interface RestServiceConfig {
     apiKey?: string;
     accessToken?: string;
     tenant?: string;
+    iamUrl?: string;
+    paUrl?: string;
+    cpdUrl?: string;
+    gateway?: string;
+    integratedLogin?: boolean;
+    integratedLoginDomain?: string;
+    integratedLoginService?: string;
+    integratedLoginHost?: string;
+    integratedLoginDelegate?: boolean;
+    proxies?: {
+        http?: string;
+        https?: string;
+    };
+    sslContext?: https.Agent;
+    cert?: string | [string, string];
+    reConnectOnSessionTimeout?: boolean;
+    reConnectOnRemoteDisconnect?: boolean;
+    remoteDisconnectMaxRetries?: number;
+    remoteDisconnectRetryDelay?: number;
+    remoteDisconnectMaxDelay?: number;
+}
+export interface RequestOptions extends Omit<AxiosRequestConfig, 'timeout'> {
+    asyncRequestsMode?: boolean;
+    returnAsyncId?: boolean;
+    timeout?: number;
+    cancelAtTimeout?: boolean;
+    idempotent?: boolean;
+    verifyResponse?: boolean;
 }
 export declare class RestService {
     private static readonly HEADERS;
     private static readonly DEFAULT_CONNECTION_POOL_SIZE;
     private static readonly DEFAULT_POOL_CONNECTIONS;
+    private static readonly SESSION_COOKIE_NAMES;
     private axiosInstance;
     private config;
-    private sessionId?;
+    private sessionCookies;
     private sandboxName?;
     private isConnected;
     private _serverVersion?;
+    private _asyncRequestsMode;
+    private _cancelAtTimeout;
+    private _timeout;
+    private _asyncPollingInitialDelay;
+    private _asyncPollingMaxDelay;
+    private _asyncPollingBackoffFactor;
+    private _reConnectOnSessionTimeout;
+    private _reConnectOnRemoteDisconnect;
+    private _remoteDisconnectMaxRetries;
+    private _remoteDisconnectRetryDelay;
+    private _remoteDisconnectMaxDelay;
+    private _isAdmin?;
+    private _isDataAdmin?;
+    private _isSecurityAdmin?;
+    private _isOpsAdmin?;
+    private _activeUserGroupsPromise?;
     get version(): string | undefined;
+    get isAdmin(): boolean;
+    get isDataAdmin(): boolean;
+    get isSecurityAdmin(): boolean;
+    get isOpsAdmin(): boolean;
     constructor(config: RestServiceConfig);
+    private getSessionCookieValue;
+    private buildCookieHeader;
+    private parseSetCookieHeaders;
+    private removeAuthorizationHeader;
+    private deleteHeaderCaseInsensitive;
     private setupAxiosInstance;
     private buildBaseUrl;
+    /**
+     * Pick the deployment topology based on the provided config, mirroring
+     * tm1py's _determine_auth_mode + _construct_service_and_auth_root dispatch.
+     *
+     * Note: authUrl is intentionally excluded from the v12 signal set because
+     * tm1npm historically uses authUrl for CAM SSO (unlike tm1py, where auth_url
+     * is a v12-only field). apiKey is also excluded to avoid collision with the
+     * existing BASIC_API_KEY auth flow.
+     */
+    private determineTopology;
+    /**
+     * Resolve the TM1 service root and auth root URLs for the configured topology.
+     * Mirrors tm1py's _construct_service_and_auth_root return tuple.
+     */
+    private resolveRoots;
+    private rootsV11;
+    private rootsIbmCloud;
+    private rootsPaProxy;
+    private rootsS2s;
+    private rootsFromBaseUrl;
     private setupInterceptors;
     /**
      * Determine if a request should be retried
@@ -61,42 +139,118 @@ export declare class RestService {
      */
     private canRetryRequest;
     /**
-     * Retry a failed request with exponential backoff
+     * Retry a failed request with exponential backoff, reconnecting the
+     * session before replay. Mirrors tm1py's _handle_remote_disconnect,
+     * which calls _manage_http_adapter() + connect() prior to retrying
+     * so a dropped session is re-established rather than replayed dead.
      */
     private retryRequest;
     private extractErrorMessage;
+    private waitTimeGenerator;
+    private _executeSyncRequest;
+    private _executeAsyncRequest;
+    private _pollAsyncResponse;
+    private _request;
     connect(): Promise<void>;
     disconnect(): Promise<void>;
-    get(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse>;
-    post(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse>;
-    patch(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse>;
-    put(url: string, data?: any, config?: AxiosRequestConfig): Promise<AxiosResponse>;
-    delete(url: string, config?: AxiosRequestConfig): Promise<AxiosResponse>;
+    /**
+     * When `returnAsyncId: true`, the caller receives the async id string
+     * iff the server returns `202 Accepted`. If TM1 short-circuits with
+     * `200/201`, the full `AxiosResponse` is returned instead — the
+     * declared `Promise<string>` return type is a best-effort narrowing.
+     */
+    get(url: string, options: RequestOptions & {
+        returnAsyncId: true;
+    }): Promise<string | AxiosResponse>;
+    get(url: string, options?: RequestOptions): Promise<AxiosResponse>;
+    post(url: string, data: any, options: RequestOptions & {
+        returnAsyncId: true;
+    }): Promise<string | AxiosResponse>;
+    post(url: string, data?: any, options?: RequestOptions): Promise<AxiosResponse>;
+    patch(url: string, data: any, options: RequestOptions & {
+        returnAsyncId: true;
+    }): Promise<string | AxiosResponse>;
+    patch(url: string, data?: any, options?: RequestOptions): Promise<AxiosResponse>;
+    put(url: string, data: any, options: RequestOptions & {
+        returnAsyncId: true;
+    }): Promise<string | AxiosResponse>;
+    put(url: string, data?: any, options?: RequestOptions): Promise<AxiosResponse>;
+    delete(url: string, options: RequestOptions & {
+        returnAsyncId: true;
+    }): Promise<string | AxiosResponse>;
+    delete(url: string, options?: RequestOptions): Promise<AxiosResponse>;
     getSessionId(): string | undefined;
     setSandbox(sandboxName?: string): void;
     getSandbox(): string | undefined;
     isLoggedIn(): boolean;
     getApiMetadata(): Promise<any>;
     /**
-     * Set up authentication based on configuration
+     * Build an httpsAgent option that skips TLS verification when verify is false.
      */
-    private setupAuthentication;
+    private static insecureAgentOption;
+    /**
+     * Normalise a Set-Cookie header value (string | string[] | undefined) into a string[].
+     */
+    private static normaliseSetCookie;
+    /**
+     * Extract a named cookie value from raw Set-Cookie headers.
+     */
+    private static extractCookieValue;
+    /**
+     * Build Basic Authorization header.
+     * Mirrors tm1py's _build_authorization_token_basic.
+     */
+    private static _buildAuthorizationTokenBasic;
+    /**
+     * Build CAMNamespace Authorization header.
+     * Mirrors tm1py's _build_authorization_token_cam (non-gateway path).
+     */
+    private static _buildAuthorizationTokenCam;
     /**
-     * Set up CAM (Cognos Access Manager) authentication
+     * Build CAMPassport Authorization token via gateway SSO.
+     * Mirrors tm1py's _build_authorization_token_cam (gateway path).
+     * Makes a GET request to the gateway URL with CAMNamespace as a query
+     * parameter and extracts the cam_passport cookie from the response.
+     *
+     * Note: tm1py uses HttpNegotiateAuth (NTLM/Kerberos) for gateway requests,
+     * which is Windows-only. This implementation sends a plain GET and relies on
+     * the gateway being accessible without NTLM. For environments requiring NTLM,
+     * pass a pre-obtained cam_passport via config.camPassport instead.
      */
-    private setupCamAuthentication;
+    private static _buildAuthorizationTokenCamSso;
     /**
-     * Set up CAM SSO authentication
+     * Generate IBM IAM Cloud access token.
+     * Mirrors tm1py's _generate_ibm_iam_cloud_access_token.
      */
-    private setupCamSsoAuthentication;
+    private _generateIbmIamCloudAccessToken;
     /**
-     * Set up Service-to-Service authentication
+     * Generate CPD (Cloud Pak for Data) access token.
+     * Mirrors tm1py's _generate_cpd_access_token.
      */
-    private setupServiceToServiceAuthentication;
+    private _generateCpdAccessToken;
     /**
-     * Get the authentication mode being used
+     * Authenticate with PA Proxy using a CPD JWT token.
+     * Mirrors tm1py's PA_PROXY flow in _start_session.
+     */
+    private _authenticateWithPaProxy;
+    /**
+     * Authenticate Service-to-Service (v12).
+     * Mirrors tm1py's SERVICE_TO_SERVICE flow in _start_session:
+     * Uses Basic auth with applicationClientId:applicationClientSecret,
+     * then POSTs {"User": user} to the auth endpoint.
+     */
+    private _authenticateServiceToService;
+    /**
+     * Determine the authentication mode from config.
+     * Mirrors tm1py's _determine_auth_mode, using the URL topology as the
+     * primary discriminator for v12 modes.
      */
     getAuthenticationMode(): AuthenticationMode;
+    /**
+     * Set up authentication based on configuration.
+     * Mirrors tm1py's _start_session routing.
+     */
+    private setupAuthentication;
     /**
      * Re-authenticate using stored configuration
      */
@@ -162,19 +316,27 @@ export declare class RestService {
      */
     set_version(version: string): void;
     /**
-     * Check if current user is admin
+     * Fetch the active user's group names as a CaseAndSpaceInsensitiveSet so
+     * membership tests are case- and whitespace-insensitive (mirrors tm1py).
+     * Concurrent callers (e.g. Promise.all([is_admin(), is_data_admin(), ...]))
+     * coalesce onto a single in-flight request.
+     */
+    private fetchActiveUserGroupNames;
+    /**
+     * Check if current user is admin. Result is cached after the first
+     * computation, and pre-populated when the configured user is ADMIN.
      */
     is_admin(): Promise<boolean>;
     /**
-     * Check if current user is data admin
+     * Check if current user is data admin (member of Admin or DataAdmin).
      */
     is_data_admin(): Promise<boolean>;
     /**
-     * Check if current user is ops admin
+     * Check if current user is ops admin (member of Admin or OperationsAdmin).
      */
     is_ops_admin(): Promise<boolean>;
     /**
-     * Check if current user is security admin
+     * Check if current user is security admin (member of Admin or SecurityAdmin).
      */
     is_security_admin(): Promise<boolean>;
     /**
@@ -191,6 +353,23 @@ export declare class RestService {
     get_http_headers(): {
         [key: string]: string;
     };
+    /**
+     * Insert `tm1.compact=v0` into the Accept header (after the
+     * `application/json` segment) and return the previous header value.
+     * Mirrors tm1py's add_compact_json_header.
+     */
+    add_compact_json_header(): string;
+    /**
+     * Decode a Base64-encoded password to its UTF-8 plaintext form
+     * (mirrors tm1py's b64_decode_password).
+     */
+    static b64_decode_password(encryptedPassword: string): string;
+    /**
+     * Coerce a boolean/number/string config value to a boolean. Strings
+     * are stripped of whitespace and lowercased before comparison with
+     * `'true'` (mirrors tm1py's translate_to_boolean).
+     */
+    static translate_to_boolean(value: unknown): boolean;
     /**
      * Cancel an async operation by ID
      */
@@ -198,15 +377,24 @@ export declare class RestService {
     /**
      * Retrieve async operation response
      */
-    retrieve_async_response(async_id: string): Promise<any>;
+    retrieve_async_response(async_id: string): Promise<AxiosResponse>;
     /**
-     * Get async operation status
+     * TM1 v12 returns completed async results with HTTP 200 and encodes
+     * the true operation status in the `asyncresult` header (e.g.
+     * "500 Internal Server Error"). Mirror tm1py's
+     * `_transform_async_response` by throwing on any embedded non-2xx
+     * status so callers are not handed a 500 as "success".
      */
-    get_async_operation_status(async_id: string): Promise<string>;
+    private verifyAsyncResultHeader;
     /**
-     * Wait for async operation to complete
+     * Wait for async operation to complete using a fixed polling cadence.
+     *
+     * Unlike the internal dispatcher's {@link waitTimeGenerator} (capped
+     * exponential backoff), this public helper polls every
+     * {@link poll_interval_seconds} seconds so existing callers who tuned
+     * the cadence keep their original behavior.
      */
-    wait_for_async_operation(async_id: string, timeout_seconds?: number, poll_interval_seconds?: number): Promise<any>;
+    wait_for_async_operation(async_id: string, timeout_seconds?: number, poll_interval_seconds?: number, cancel_at_timeout?: boolean): Promise<any>;
     /**
      * Get active user name
      */