tm1npm 1.0.0

package/lib/tests/tm1Service.test.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * TM1Service Tests
+ * Comprehensive test suite for the main TM1Service class
+ * Target: Improve coverage from 0% to 40%+
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const TM1Service_1 = require("../services/TM1Service");
+const RestService_1 = require("../services/RestService");
+// Mock all service dependencies
+jest.mock('../services/RestService');
+jest.mock('../services/DimensionService');
+jest.mock('../services/HierarchyService');
+jest.mock('../services/SubsetService');
+jest.mock('../services/CubeService');
+jest.mock('../services/ElementService');
+jest.mock('../services/CellService');
+jest.mock('../services/ProcessService');
+jest.mock('../services/ViewService');
+jest.mock('../services/SecurityService');
+jest.mock('../services/FileService');
+jest.mock('../services/SessionService');
+jest.mock('../services/ServerService');
+jest.mock('../services/MonitoringService');
+describe('TM1Service', () => {
+    let tm1Service;
+    let mockRestService;
+    let mockConfig;
+    const mockResponse = (data) => ({
+        data: data,
+        status: 200,
+        statusText: 'OK',
+        headers: {},
+        config: { headers: {} }
+    });
+    beforeEach(() => {
+        // Reset all mocks
+        jest.clearAllMocks();
+        mockConfig = {
+            address: 'localhost',
+            port: 8879,
+            user: 'admin',
+            password: 'password',
+            ssl: false
+        };
+        // Create mock RestService instance
+        mockRestService = {
+            connect: jest.fn().mockResolvedValue(void 0),
+            disconnect: jest.fn().mockResolvedValue(void 0),
+            get: jest.fn().mockResolvedValue(mockResponse),
+            post: jest.fn().mockResolvedValue(mockResponse),
+            patch: jest.fn().mockResolvedValue(mockResponse),
+            put: jest.fn().mockResolvedValue(mockResponse),
+            delete: jest.fn().mockResolvedValue(mockResponse),
+            getSessionId: jest.fn().mockReturnValue('test-session-id'),
+            setSandbox: jest.fn(),
+            getSandbox: jest.fn().mockReturnValue('test-sandbox'),
+            isLoggedIn: jest.fn().mockReturnValue(true),
+        };
+        // Mock RestService constructor
+        RestService_1.RestService.mockImplementation(() => mockRestService);
+        tm1Service = new TM1Service_1.TM1Service(mockConfig);
+    });
+    describe('Constructor and Initialization', () => {
+        test('should initialize TM1Service with all service properties', () => {
+            expect(tm1Service).toBeDefined();
+            expect(tm1Service.dimensions).toBeDefined();
+            expect(tm1Service.hierarchies).toBeDefined();
+            expect(tm1Service.subsets).toBeDefined();
+            expect(tm1Service.cubes).toBeDefined();
+            expect(tm1Service.elements).toBeDefined();
+            expect(tm1Service.cells).toBeDefined();
+            expect(tm1Service.processes).toBeDefined();
+            expect(tm1Service.views).toBeDefined();
+            expect(tm1Service.security).toBeDefined();
+            expect(tm1Service.files).toBeDefined();
+            expect(tm1Service.sessions).toBeDefined();
+        });
+        test('should create RestService with provided config', () => {
+            expect(RestService_1.RestService).toHaveBeenCalledWith(mockConfig);
+        });
+        test('should initialize all services with REST service instance', () => {
+            // Verify that all service constructors were called
+            expect(RestService_1.RestService).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('Connection Management', () => {
+        test('should connect successfully', async () => {
+            await tm1Service.connect();
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+        });
+        test('should logout successfully', async () => {
+            await tm1Service.logout();
+            expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
+        });
+        test('should disconnect successfully (alias for logout)', async () => {
+            await tm1Service.disconnect();
+            expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
+        });
+        test('should handle connection errors gracefully', async () => {
+            const connectionError = new Error('Connection failed');
+            mockRestService.connect.mockRejectedValueOnce(connectionError);
+            await expect(tm1Service.connect()).rejects.toThrow('Connection failed');
+        });
+        test('should handle logout errors gracefully', async () => {
+            const logoutError = new Error('Logout failed');
+            mockRestService.disconnect.mockRejectedValueOnce(logoutError);
+            await expect(tm1Service.logout()).rejects.toThrow('Logout failed');
+        });
+    });
+    describe('Service Properties - Lazy Loading', () => {
+        test('should create server service lazily', () => {
+            const server1 = tm1Service.server;
+            const server2 = tm1Service.server;
+            expect(server1).toBeDefined();
+            expect(server2).toBe(server1); // Should return same instance
+        });
+        test('should create monitoring service lazily', () => {
+            const monitoring1 = tm1Service.monitoring;
+            const monitoring2 = tm1Service.monitoring;
+            expect(monitoring1).toBeDefined();
+            expect(monitoring2).toBe(monitoring1); // Should return same instance
+        });
+    });
+    describe('User and Authentication', () => {
+        test('should get current user with whoami', async () => {
+            // Mock security service getCurrentUser method
+            const mockSecurityService = {
+                getCurrentUser: jest.fn().mockResolvedValue({ name: 'test-user' })
+            };
+            tm1Service.security = mockSecurityService;
+            const result = await tm1Service.whoami();
+            expect(result).toBe('test-user');
+            expect(mockSecurityService.getCurrentUser).toHaveBeenCalledTimes(1);
+        });
+        test('should check if user is logged in', () => {
+            mockRestService.isLoggedIn.mockReturnValue(true);
+            const result = tm1Service.isLoggedIn();
+            expect(result).toBe(true);
+            expect(mockRestService.isLoggedIn).toHaveBeenCalledTimes(1);
+        });
+        test('should check if user is not logged in', () => {
+            mockRestService.isLoggedIn.mockReturnValue(false);
+            const result = tm1Service.isLoggedIn();
+            expect(result).toBe(false);
+        });
+        test('should re-authenticate successfully', async () => {
+            await tm1Service.reAuthenticate();
+            expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe('Metadata and Version', () => {
+        test('should get TM1 metadata', async () => {
+            mockRestService.get.mockResolvedValueOnce(mockResponse({ metadata: 'test-metadata' }));
+            const result = await tm1Service.getMetadata();
+            expect(result).toEqual({ metadata: 'test-metadata' });
+            expect(mockRestService.get).toHaveBeenCalledWith('/$metadata');
+        });
+        test('should get TM1 version', async () => {
+            mockRestService.get.mockResolvedValueOnce(mockResponse({ value: '12.0.0' }));
+            const result = await tm1Service.getVersion();
+            expect(result).toBe('12.0.0');
+            expect(mockRestService.get).toHaveBeenCalledWith('/Configuration/ProductVersion');
+        });
+        test('should handle metadata retrieval errors', async () => {
+            const metadataError = new Error('Metadata not available');
+            mockRestService.get.mockRejectedValueOnce(metadataError);
+            await expect(tm1Service.getMetadata()).rejects.toThrow('Metadata not available');
+        });
+        test('should handle version retrieval errors', async () => {
+            const versionError = new Error('Version not available');
+            mockRestService.get.mockRejectedValueOnce(versionError);
+            await expect(tm1Service.getVersion()).rejects.toThrow('Version not available');
+        });
+    });
+    describe('Session Management', () => {
+        test('should get session ID', () => {
+            mockRestService.getSessionId.mockReturnValue('test-session-123');
+            const result = tm1Service.getSessionId();
+            expect(result).toBe('test-session-123');
+            expect(mockRestService.getSessionId).toHaveBeenCalledTimes(1);
+        });
+        test('should handle undefined session ID', () => {
+            mockRestService.getSessionId.mockReturnValue(undefined);
+            const result = tm1Service.getSessionId();
+            expect(result).toBeUndefined();
+        });
+        test('should get connection instance', () => {
+            const connection = tm1Service.connection;
+            expect(connection).toBe(mockRestService);
+        });
+    });
+    describe('Sandbox Management', () => {
+        test('should set sandbox name', () => {
+            tm1Service.setSandbox('test-sandbox');
+            expect(mockRestService.setSandbox).toHaveBeenCalledWith('test-sandbox');
+        });
+        test('should set sandbox to undefined', () => {
+            tm1Service.setSandbox(undefined);
+            expect(mockRestService.setSandbox).toHaveBeenCalledWith(undefined);
+        });
+        test('should get current sandbox', () => {
+            mockRestService.getSandbox.mockReturnValue('current-sandbox');
+            const result = tm1Service.getSandbox();
+            expect(result).toBe('current-sandbox');
+            expect(mockRestService.getSandbox).toHaveBeenCalledTimes(1);
+        });
+        test('should handle undefined sandbox', () => {
+            mockRestService.getSandbox.mockReturnValue(undefined);
+            const result = tm1Service.getSandbox();
+            expect(result).toBeUndefined();
+        });
+    });
+    describe('Static Factory Method', () => {
+        test('should create and connect TM1Service instance', async () => {
+            const service = await TM1Service_1.TM1Service.create(mockConfig);
+            expect(service).toBeInstanceOf(TM1Service_1.TM1Service);
+            expect(mockRestService.connect).toHaveBeenCalledTimes(1);
+        });
+        test('should handle creation errors', async () => {
+            const createError = new Error('Creation failed');
+            mockRestService.connect.mockRejectedValueOnce(createError);
+            await expect(TM1Service_1.TM1Service.create(mockConfig)).rejects.toThrow('Creation failed');
+        });
+    });
+    describe('Disposal and Cleanup', () => {
+        test('should dispose successfully', async () => {
+            await tm1Service.dispose();
+            expect(mockRestService.disconnect).toHaveBeenCalledTimes(1);
+        });
+        test('should handle dispose errors gracefully with console warning', async () => {
+            const disposeError = new Error('Dispose failed');
+            mockRestService.disconnect.mockRejectedValueOnce(disposeError);
+            // Mock console.warn to verify it's called
+            const consoleSpy = jest.spyOn(console, 'warn').mockImplementation();
+            // Should not throw, should log warning instead
+            await expect(tm1Service.dispose()).resolves.not.toThrow();
+            expect(consoleSpy).toHaveBeenCalledWith('Logout failed due to exception: Error: Dispose failed');
+            consoleSpy.mockRestore();
+        });
+    });
+    describe('Error Handling and Edge Cases', () => {
+        test('should handle whoami when security service fails', async () => {
+            const mockSecurityService = {
+                getCurrentUser: jest.fn().mockRejectedValue(new Error('Security error'))
+            };
+            tm1Service.security = mockSecurityService;
+            await expect(tm1Service.whoami()).rejects.toThrow('Security error');
+        });
+        test('should handle re-authentication when disconnect fails', async () => {
+            const disconnectError = new Error('Disconnect failed');
+            mockRestService.disconnect.mockRejectedValueOnce(disconnectError);
+            await expect(tm1Service.reAuthenticate()).rejects.toThrow('Disconnect failed');
+        });
+        test('should handle re-authentication when connect fails after disconnect', async () => {
+            const connectError = new Error('Reconnect failed');
+            mockRestService.disconnect.mockResolvedValueOnce(void 0);
+            mockRestService.connect.mockRejectedValueOnce(connectError);
+            await expect(tm1Service.reAuthenticate()).rejects.toThrow('Reconnect failed');
+        });
+    });
+    describe('Service Integration', () => {
+        test('should have all required service properties initialized', () => {
+            const requiredServices = [
+                'dimensions', 'hierarchies', 'subsets', 'cubes',
+                'elements', 'cells', 'processes', 'views',
+                'security', 'files', 'sessions'
+            ];
+            requiredServices.forEach(service => {
+                expect(tm1Service[service]).toBeDefined();
+            });
+        });
+        test('should provide lazy-loaded services', () => {
+            // These are lazy-loaded via getters
+            expect(tm1Service.server).toBeDefined();
+            expect(tm1Service.monitoring).toBeDefined();
+        });
+        test('should maintain consistent lazy-loaded service instances', () => {
+            // Call multiple times to ensure same instance is returned
+            const server1 = tm1Service.server;
+            const server2 = tm1Service.server;
+            const monitoring1 = tm1Service.monitoring;
+            const monitoring2 = tm1Service.monitoring;
+            expect(server1).toBe(server2);
+            expect(monitoring1).toBe(monitoring2);
+        });
+    });
+});
+//# sourceMappingURL=tm1Service.test.js.map

package/lib/tests/viewService.test.d.ts

@@ -0,0 +1,6 @@
+/**
+ * ViewService Tests for tm1npm
+ * Comprehensive tests for TM1 View operations with proper mocking
+ */
+export {};
+//# sourceMappingURL=viewService.test.d.ts.map

package/lib/tests/viewService.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viewService.test.d.ts","sourceRoot":"","sources":["../../src/tests/viewService.test.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/lib/tests/viewService.test.js

@@ -0,0 +1,240 @@
+"use strict";
+/**
+ * ViewService Tests for tm1npm
+ * Comprehensive tests for TM1 View operations with proper mocking
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const ViewService_1 = require("../services/ViewService");
+const NativeView_1 = require("../objects/NativeView");
+const MDXView_1 = require("../objects/MDXView");
+const TM1Exception_1 = require("../exceptions/TM1Exception");
+// Helper function to create mock AxiosResponse
+const createMockResponse = (data, status = 200) => ({
+    data,
+    status,
+    statusText: status === 200 ? 'OK' : status === 201 ? 'Created' : status === 204 ? 'No Content' : 'Error',
+    headers: {},
+    config: {}
+});
+describe('ViewService Tests', () => {
+    let viewService;
+    let mockRestService;
+    beforeEach(() => {
+        // Create comprehensive mock for RestService
+        mockRestService = {
+            get: jest.fn(),
+            post: jest.fn(),
+            patch: jest.fn(),
+            delete: jest.fn(),
+            put: jest.fn(),
+            config: {},
+            rest: {},
+            buildBaseUrl: jest.fn(),
+            extractErrorMessage: jest.fn()
+        };
+        viewService = new ViewService_1.ViewService(mockRestService);
+    });
+    describe('View Retrieval Operations', () => {
+        test('should get all view names for cube', async () => {
+            // Mock both private and public view calls
+            mockRestService.get
+                .mockResolvedValueOnce(createMockResponse({
+                value: [{ Name: 'PrivateView1' }]
+            }))
+                .mockResolvedValueOnce(createMockResponse({
+                value: [{ Name: 'PublicView1' }, { Name: 'PublicView2' }]
+            }));
+            const viewNames = await viewService.getAllNames('TestCube');
+            expect(Array.isArray(viewNames)).toBe(true);
+            expect(viewNames.length).toBe(3);
+            expect(viewNames).toEqual(['PrivateView1', 'PublicView1', 'PublicView2']);
+            console.log('✅ View names retrieved successfully');
+        });
+        test('should get all views for cube', async () => {
+            // Mock the main views call - first call for getAll
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                value: [
+                    { Name: 'MDXView1', MDX: 'SELECT FROM [TestCube]' }, // Has MDX property
+                    { Name: 'NativeView1' } // Doesn't have MDX property  
+                ]
+            }));
+            // Mock the getNativeView call that will be made for the native view
+            mockRestService.get.mockResolvedValueOnce(createMockResponse({
+                Name: 'NativeView1',
+                Columns: [],
+                Rows: [],
+                Titles: []
+            }));
+            const views = await viewService.getAll('TestCube');
+            expect(Array.isArray(views)).toBe(true);
+            expect(views.length).toBe(2); // Returns [nativeViews, mdxViews]
+            expect(views[0]).toEqual(expect.any(Array)); // nativeViews array
+            expect(views[1]).toEqual(expect.any(Array)); // mdxViews array
+            console.log('✅ All views retrieved successfully');
+        });
+        test('should check if view exists', async () => {
+            // Test existing view
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'ExistingView'
+            }));
+            const exists = await viewService.exists('TestCube', 'ExistingView', false);
+            expect(exists).toBe(true);
+            console.log('✅ View existence check working correctly');
+        });
+        test('should check if view does not exist', async () => {
+            // Test non-existing view
+            const mockError = new TM1Exception_1.TM1RestException('View not found', 404, { status: 404 });
+            mockRestService.get.mockRejectedValue(mockError);
+            const notExists = await viewService.exists('TestCube', 'NonExistentView', false);
+            expect(notExists).toBe(false);
+            console.log('✅ View non-existence check working correctly');
+        });
+    });
+    describe('View CRUD Operations', () => {
+        test('should create native view', async () => {
+            const mockNativeView = new NativeView_1.NativeView('TestCube', 'NewNativeView');
+            mockRestService.post.mockResolvedValue(createMockResponse({ Name: 'NewNativeView' }, 201));
+            const result = await viewService.create(mockNativeView);
+            expect(mockRestService.post).toHaveBeenCalled();
+            expect(result.status).toBe(201);
+            console.log('✅ Native view creation successful');
+        });
+        test('should create MDX view', async () => {
+            const mockMDXView = new MDXView_1.MDXView('TestCube', 'NewMDXView', 'SELECT FROM [TestCube]');
+            mockRestService.post.mockResolvedValue(createMockResponse({ Name: 'NewMDXView' }, 201));
+            const result = await viewService.create(mockMDXView);
+            expect(result.status).toBe(201);
+            console.log('✅ MDX view creation successful');
+        });
+        test('should update existing view', async () => {
+            const mockView = new NativeView_1.NativeView('TestCube', 'UpdatedView');
+            mockRestService.patch.mockResolvedValue(createMockResponse({ Name: 'UpdatedView' }, 200));
+            const result = await viewService.update(mockView);
+            expect(mockRestService.patch).toHaveBeenCalled();
+            expect(result.status).toBe(200);
+            console.log('✅ View update successful');
+        });
+        test('should delete view', async () => {
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            const result = await viewService.delete('TestCube', 'ViewToDelete');
+            expect(mockRestService.delete).toHaveBeenCalled();
+            expect(result.status).toBe(204);
+            console.log('✅ View deletion successful');
+        });
+    });
+    describe('View Error Handling', () => {
+        test('should handle network errors gracefully', async () => {
+            mockRestService.get.mockRejectedValue({
+                code: 'ECONNREFUSED'
+            });
+            await expect(viewService.getAllNames('TestCube'))
+                .rejects.toMatchObject({
+                code: 'ECONNREFUSED'
+            });
+            console.log('✅ Network error handling working');
+        });
+        test('should handle authentication errors', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 401 }
+            });
+            await expect(viewService.getAll('TestCube'))
+                .rejects.toMatchObject({
+                response: { status: 401 }
+            });
+            console.log('✅ Authentication error handling working');
+        });
+        test('should handle invalid cube names', async () => {
+            mockRestService.get.mockRejectedValue({
+                response: { status: 400, statusText: 'Bad Request' }
+            });
+            await expect(viewService.getAllNames('')).rejects.toMatchObject({
+                response: { status: 400 }
+            });
+            console.log('✅ Invalid input handling working');
+        });
+    });
+    describe('View Service Edge Cases', () => {
+        test('should handle empty view lists', async () => {
+            // Mock both private and public calls returning empty
+            mockRestService.get
+                .mockResolvedValueOnce(createMockResponse({ value: [] }))
+                .mockResolvedValueOnce(createMockResponse({ value: [] }));
+            const views = await viewService.getAllNames('EmptyCube');
+            expect(Array.isArray(views)).toBe(true);
+            expect(views.length).toBe(0);
+            console.log('✅ Empty view list handling working');
+        });
+        test('should handle concurrent operations', async () => {
+            // Mock both private and public calls for each concurrent operation
+            mockRestService.get.mockImplementation(() => Promise.resolve(createMockResponse({
+                value: [{ Name: 'TestView' }]
+            })));
+            const operations = [
+                viewService.getAllNames('TestCube'),
+                viewService.getAllNames('TestCube'),
+                viewService.getAllNames('TestCube')
+            ];
+            const results = await Promise.allSettled(operations);
+            const successful = results.filter(r => r.status === 'fulfilled');
+            expect(successful.length).toBe(3);
+            console.log('✅ Concurrent operations handling working');
+        });
+        test('should handle large view datasets efficiently', async () => {
+            const largeViewList = Array(1000).fill(null).map((_, i) => ({
+                Name: `View${i}`
+            }));
+            // Mock both calls returning large datasets
+            mockRestService.get
+                .mockResolvedValueOnce(createMockResponse({ value: largeViewList.slice(0, 500) }))
+                .mockResolvedValueOnce(createMockResponse({ value: largeViewList.slice(500) }));
+            const startTime = Date.now();
+            const result = await viewService.getAllNames('LargeCube');
+            const endTime = Date.now();
+            expect(result.length).toBe(1000);
+            expect(endTime - startTime).toBeLessThan(1000); // Should be fast with mocking
+            console.log('✅ Large dataset handling efficient');
+        });
+    });
+    describe('View Service Integration', () => {
+        test('should maintain data consistency across operations', async () => {
+            const viewList = [
+                { Name: 'View1' },
+                { Name: 'View2' }
+            ];
+            // Mock consistent responses
+            mockRestService.get.mockImplementation(() => Promise.resolve(createMockResponse({
+                value: viewList
+            })));
+            const names1 = await viewService.getAllNames('TestCube');
+            const names2 = await viewService.getAllNames('TestCube');
+            // Note: getAllNames returns combined private+public, so results will be ['View1', 'View2', 'View1', 'View2']
+            expect(names1.length).toBeGreaterThan(0);
+            expect(names2.length).toBeGreaterThan(0);
+            console.log('✅ Data consistency maintained');
+        });
+        test('should handle view lifecycle operations', async () => {
+            const testView = new NativeView_1.NativeView('TestCube', 'LifecycleView');
+            // Mock create
+            mockRestService.post.mockResolvedValue(createMockResponse({}, 201));
+            // Mock get (exists)
+            mockRestService.get.mockResolvedValue(createMockResponse({
+                Name: 'LifecycleView'
+            }));
+            // Mock update
+            mockRestService.patch.mockResolvedValue(createMockResponse({}, 200));
+            // Mock delete
+            mockRestService.delete.mockResolvedValue(createMockResponse({}, 204));
+            // Test full lifecycle
+            const createResult = await viewService.create(testView);
+            expect(createResult.status).toBe(201);
+            const exists = await viewService.exists('TestCube', 'LifecycleView', false);
+            expect(exists).toBe(true);
+            const updateResult = await viewService.update(testView);
+            expect(updateResult.status).toBe(200);
+            const deleteResult = await viewService.delete('TestCube', 'LifecycleView');
+            expect(deleteResult.status).toBe(204);
+            console.log('✅ View lifecycle operations working');
+        });
+    });
+});
+//# sourceMappingURL=viewService.test.js.map

package/lib/utils/Utils.d.ts

@@ -0,0 +1,90 @@
+export declare class CaseAndSpaceInsensitiveDict<T> extends Map<string, T> {
+    private normalizeKey;
+    set(key: string, value: T): this;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+}
+export declare class CaseAndSpaceInsensitiveTuplesDict<T> extends Map<string, T> {
+    private normalizeKey;
+    set(key: string, value: T): this;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+}
+export declare class CaseAndSpaceInsensitiveMap<T> extends Map<string, T> {
+    private normalizeKey;
+    set(key: string, value: T): this;
+    get(key: string): T | undefined;
+    has(key: string): boolean;
+    delete(key: string): boolean;
+}
+export declare class CaseAndSpaceInsensitiveSet extends Set<string> {
+    private normalizeValue;
+    add(value: string): this;
+    has(value: string): boolean;
+    delete(value: string): boolean;
+}
+export declare function caseAndSpaceInsensitiveEquals(str1: string, str2: string): boolean;
+export declare function lowerAndDropSpaces(str: string): string;
+export declare function formatUrl(template: string, ...args: string[]): string;
+export declare function extractCellsetCells(cellset: any): any[];
+export declare function buildMdxFromAxes(axes: any[]): string;
+export declare function buildElementsStringFromIterable(elements: Iterable<string>, separator?: string): string;
+export declare function dimensionHierarchyElementTupleFromUniqueName(uniqueName: string): [string, string, string];
+export declare function buildElementUniqueNames(elements: string[], dimensionName: string, hierarchyName?: string): string[];
+export declare function dimensionHierarchyElementTupleFromString(dimensionHierarchyElement: string): [string, string, string];
+export declare function deprecatedInVersion(version: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function requireVersion(minVersion: string): (target: any, propertyKey: string, descriptor: PropertyDescriptor) => void;
+export declare function requireAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+export declare function requireDataAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+export declare function requireSecurityAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+export declare function requireOpsAdmin(target: any, propertyKey: string, descriptor: PropertyDescriptor): void;
+export declare function wrapTupleInBrackets(members: string[]): string;
+export declare function abbreviateString(text: string, maxLength: number): string;
+export declare function getTimeFromTimeStamp(timestamp: string): Date;
+export declare function addTimeToTimeStamp(timestamp: string, hours: number): string;
+export declare function tidy(inputString: string): string;
+export declare function getMdxElementFromAttribute(attribute: string, cube: string): string;
+export declare function buildMdxTuple(members: string[]): string;
+export declare function verifyVersion(actualVersion: string, requiredVersion: string): boolean;
+export declare function readObjectNameFromUrl(url: string): string;
+export declare function integerizeVersion(version: string): number;
+export declare function frameToSignificantValue(value: any): any;
+export declare class HTTPAdapterWithSocketOptions {
+    private socketOptions;
+    constructor(socketOptions?: any);
+}
+export declare function odataTrackChangesHeader(): Record<string, string>;
+export declare function utcLocalizeTime(utcTimeStr: string): Date;
+export declare function decohints(): string;
+export declare const Utils: {
+    CaseAndSpaceInsensitiveMap: typeof CaseAndSpaceInsensitiveMap;
+    CaseAndSpaceInsensitiveSet: typeof CaseAndSpaceInsensitiveSet;
+    caseAndSpaceInsensitiveEquals: typeof caseAndSpaceInsensitiveEquals;
+    lowerAndDropSpaces: typeof lowerAndDropSpaces;
+    formatUrl: typeof formatUrl;
+    extractCellsetCells: typeof extractCellsetCells;
+    buildMdxFromAxes: typeof buildMdxFromAxes;
+    buildElementsStringFromIterable: typeof buildElementsStringFromIterable;
+    dimensionHierarchyElementTupleFromString: typeof dimensionHierarchyElementTupleFromString;
+    requireVersion: typeof requireVersion;
+    requireAdmin: typeof requireAdmin;
+    requireDataAdmin: typeof requireDataAdmin;
+    requireSecurityAdmin: typeof requireSecurityAdmin;
+    requireOpsAdmin: typeof requireOpsAdmin;
+    wrapTupleInBrackets: typeof wrapTupleInBrackets;
+    abbreviateString: typeof abbreviateString;
+    getTimeFromTimeStamp: typeof getTimeFromTimeStamp;
+    addTimeToTimeStamp: typeof addTimeToTimeStamp;
+    tidy: typeof tidy;
+    getMdxElementFromAttribute: typeof getMdxElementFromAttribute;
+    buildMdxTuple: typeof buildMdxTuple;
+    verifyVersion: typeof verifyVersion;
+    frameToSignificantValue: typeof frameToSignificantValue;
+    HTTPAdapterWithSocketOptions: typeof HTTPAdapterWithSocketOptions;
+    odataTrackChangesHeader: typeof odataTrackChangesHeader;
+    utcLocalizeTime: typeof utcLocalizeTime;
+    decohints: typeof decohints;
+};
+//# sourceMappingURL=Utils.d.ts.map

package/lib/utils/Utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Utils.d.ts","sourceRoot":"","sources":["../../src/utils/Utils.ts"],"names":[],"mappings":"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"}