@datalayer/core 0.0.12 → 0.0.14

package/lib/api/__tests__/iam.authentication.integration.test.js

@@ -1,247 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import { authentication } from '../iam';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-let DATALAYER_TOKEN;
-let SESSION_TOKEN;
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping IAM integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get token and base URL from test config
-    DATALAYER_TOKEN = testConfig.getToken();
-    BASE_URL = testConfig.getBaseUrl('IAM');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-    debugLog('Token available:', !!DATALAYER_TOKEN);
-    // Login to get a session token for testing
-    try {
-        const loginResponse = await authentication.login({
-            token: DATALAYER_TOKEN,
-        }, BASE_URL);
-        SESSION_TOKEN = loginResponse.token;
-        debugLog('Got session token for testing');
-    }
-    catch (error) {
-        console.error('Failed to get session token:', error);
-        // Fall back to using the DATALAYER_TOKEN
-        SESSION_TOKEN = DATALAYER_TOKEN;
-    }
-});
-describe.skipIf(skipTests)('IAM Authentication Integration Tests', () => {
-    describe('login', () => {
-        it('should successfully login with valid token (expecting 201 status)', async () => {
-            console.log('Testing login with valid token (expecting 201 Created)...');
-            // The API should return 201 Created for successful login
-            const response = await authentication.login({
-                token: DATALAYER_TOKEN,
-            }, BASE_URL);
-            console.log('Login response:', JSON.stringify(response, null, 2));
-            // Verify response structure for successful login (201 status)
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            // The message should indicate login success
-            expect(response.message.toLowerCase()).toContain('success');
-            expect(response.token).toBeDefined();
-            expect(typeof response.token).toBe('string');
-            expect(response.user).toBeDefined();
-            expect(response.user.id).toBeDefined();
-            expect(response.user.uid).toBeDefined();
-            expect(response.user.email_s).toBeDefined();
-            expect(response.user.handle_s).toBeDefined();
-            console.log('Token login successful (201 Created expected)');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('User ID:', response.user.id);
-            console.log('User UID:', response.user.uid);
-            console.log('User handle:', response.user.handle_s);
-            console.log('User email:', response.user.email_s);
-        });
-        it('should successfully login with valid token using default URL', async () => {
-            console.log('Testing login with valid token using default URL...');
-            const response = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            console.log('Login response with default URL:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.token).toBeDefined();
-            expect(typeof response.token).toBe('string');
-            expect(response.user).toBeDefined();
-            expect(response.user.id).toBeDefined();
-            expect(response.user.uid).toBeDefined();
-            expect(response.user.email_s).toBeDefined();
-            expect(response.user.handle_s).toBeDefined();
-            console.log('Token login successful with default URL');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('User ID:', response.user.id);
-            console.log('User UID:', response.user.uid);
-            console.log('User handle:', response.user.handle_s);
-            console.log('User email:', response.user.email_s);
-        });
-        it('should fail when providing invalid token (expecting 401 status)', async () => {
-            console.log('Testing login with invalid token (expecting 401 Unauthorized)...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                const response = await authentication.login({
-                    token: invalidToken,
-                }, BASE_URL);
-                console.log('Response for invalid token:', JSON.stringify(response, null, 2));
-                // If we get a response without error, check if it indicates failure
-                if (response.success === false) {
-                    console.log('Login failed as expected (success: false)');
-                    expect(response.success).toBe(false);
-                    expect(response.message).toBeDefined();
-                    expect(response.message.toLowerCase()).toContain('fail');
-                    console.log('   Error message:', response.message);
-                }
-                else {
-                    // If success is true for invalid token, that's unexpected
-                    throw new Error('Expected API to reject invalid token with 401');
-                }
-            }
-            catch (error) {
-                // The API should throw with 401 Unauthorized for invalid credentials
-                console.log('API correctly rejected invalid token with error:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // Check for expected error patterns (401 or server error)
-                const isExpectedError = error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('Login failed') ||
-                    error.message.includes('Server Error') ||
-                    error.message.includes('500');
-                expect(isExpectedError).toBe(true);
-                // Log the actual status for debugging
-                if (error.response?.status === 401) {
-                    console.log('Correctly received 401 Unauthorized status');
-                }
-                else if (error.response?.status === 500) {
-                    console.log('Received 500 Server Error (token might have invalid format)');
-                }
-            }
-        });
-    });
-    describe('proxyAuth', () => {
-        it('should successfully validate authentication with valid token', async () => {
-            console.log('Testing /proxy-auth endpoint with valid token...');
-            try {
-                await authentication.proxyAuth(SESSION_TOKEN, BASE_URL);
-                console.log('Successfully validated authentication through proxy');
-            }
-            catch (error) {
-                console.log('Proxy auth validation result:', error.message);
-                // The endpoint might not exist yet or might require specific proxy setup
-                // We'll accept either success or specific error responses
-                expect(error.message.includes('404') || // Endpoint might not exist
-                    error.message.includes('401') || // Unauthorized
-                    error.message.includes('403') || // Forbidden
-                    error.message.includes('proxy')).toBe(true);
-            }
-        });
-        it('should fail with 401 when using invalid token', async () => {
-            console.log('Testing /proxy-auth endpoint with invalid token...');
-            const invalidToken = 'invalid.token.here';
-            try {
-                await authentication.proxyAuth(invalidToken, BASE_URL);
-                // If we reach here, the endpoint accepted invalid token (shouldn't happen)
-                throw new Error('Expected proxy auth to reject invalid token');
-            }
-            catch (error) {
-                console.log('Proxy auth correctly rejected invalid token:', error.message);
-                expect(error).toBeDefined();
-                // Should get 401 Unauthorized or similar error
-                expect(error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('404')).toBe(true);
-            }
-        });
-        it('should require token parameter', async () => {
-            console.log('Testing /proxy-auth endpoint without token...');
-            try {
-                // @ts-expect-error Testing missing required parameter
-                await authentication.proxyAuth();
-                throw new Error('Expected function to throw for missing token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request without token:', error.message);
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-    });
-    describe('logout', () => {
-        // NOTE: The logout endpoint appears to return 405 Method Not Allowed
-        // This might indicate the endpoint doesn't exist or uses a different HTTP method
-        // Commenting out these tests until we can verify the correct API specification
-        it.skip('should successfully logout with valid token', async () => {
-            console.log('Testing logout with valid token...');
-            // First login to get a fresh token
-            const loginResponse = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            expect(loginResponse.success).toBe(true);
-            const sessionToken = loginResponse.token;
-            console.log('Login successful, got session token');
-            // Now test logout with the session token
-            await expect(authentication.logout(sessionToken, BASE_URL)).resolves.toBeUndefined();
-            console.log('Logout successful');
-        });
-        it.skip('should successfully logout using default URL', async () => {
-            console.log('Testing logout with valid token using default URL...');
-            // First login to get a fresh token
-            const loginResponse = await authentication.login({
-                token: DATALAYER_TOKEN,
-            });
-            expect(loginResponse.success).toBe(true);
-            const sessionToken = loginResponse.token;
-            console.log('Login successful with default URL, got session token');
-            // Now test logout with the session token using default URL
-            await expect(authentication.logout(sessionToken)).resolves.toBeUndefined();
-            console.log('Logout successful with default URL');
-        });
-        it('should handle logout with invalid token', async () => {
-            console.log('Testing logout with invalid token...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                await authentication.logout(invalidToken, BASE_URL);
-                console.log('Logout completed without error (unexpected)');
-            }
-            catch (error) {
-                console.log('Logout failed:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // Should get a server error for invalid token
-                expect(error.message).toContain('Server Error');
-            }
-        });
-        it('should verify logout accepts token as required parameter', () => {
-            // This is a compile-time test to ensure the method signature is correct
-            // The token parameter should be required
-            const mockToken = 'test-token';
-            // This should compile without errors
-            expect(() => {
-                // Test with token only (using default URL)
-                const promise1 = authentication.logout(mockToken);
-                promise1.catch(() => { }); // Ignore the actual API call
-                // Test with both token and URL
-                const promise2 = authentication.logout(mockToken, BASE_URL);
-                promise2.catch(() => { }); // Ignore the actual API call
-            }).not.toThrow();
-            console.log('Logout method signature verified: token is required, baseUrl is optional');
-        });
-    });
-});

package/lib/api/__tests__/iam.healthz.integration.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/api/__tests__/iam.healthz.integration.test.js

@@ -1,63 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import { healthz } from '../iam';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping IAM healthz integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get base URL from test config
-    BASE_URL = testConfig.getBaseUrl('IAM');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-});
-describe.skipIf(skipTests)('IAM Healthz Integration Tests', () => {
-    describe('ping endpoint', () => {
-        it('should successfully ping the IAM service', async () => {
-            console.log('Testing health check ping endpoint...');
-            const response = await healthz.ping(BASE_URL);
-            console.log('Ping response:', JSON.stringify(response, null, 2));
-            // Verify the response structure matches actual API response
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.message.toLowerCase()).toContain('running');
-            expect(response.status).toBeDefined();
-            expect(response.status.status).toBe('OK');
-            expect(response.version).toBeDefined();
-            expect(typeof response.version).toBe('string');
-            console.log('Health check successful');
-            console.log('Success:', response.success);
-            console.log('Message:', response.message);
-            console.log('Status:', response.status.status);
-            console.log('Version:', response.version);
-        });
-        it('should work with default URL if not specified', async () => {
-            console.log('Testing health check with default URL...');
-            // Call without specifying URL to use default
-            const response = await healthz.ping();
-            console.log('Default URL ping response:', JSON.stringify(response, null, 2));
-            // Should still get valid response
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.status).toBeDefined();
-            expect(response.status.status).toBe('OK');
-        });
-    });
-    describe('error handling', () => {
-        it('should handle malformed URLs gracefully', async () => {
-            console.log('Testing error handling with malformed URL...');
-            const malformedUrl = 'not-a-valid-url';
-            // ping should throw an error
-            await expect(healthz.ping(malformedUrl)).rejects.toThrow();
-        });
-    });
-});

package/lib/api/__tests__/iam.profile.integration.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/api/__tests__/iam.profile.integration.test.js

@@ -1,252 +0,0 @@
-/*
- * Copyright (c) 2023-2025 Datalayer, Inc.
- * Distributed under the terms of the Modified BSD License.
- */
-import { describe, it, expect, beforeAll } from 'vitest';
-import { authentication, profile } from '../iam';
-import { testConfig, debugLog, skipIfNoToken, } from '../../__tests__/shared/test-config';
-let DATALAYER_TOKEN;
-let SESSION_TOKEN;
-let BASE_URL;
-// Skip all tests if no token is available
-const skipTests = skipIfNoToken();
-beforeAll(async () => {
-    if (skipTests) {
-        console.log('WARNING: Skipping profile integration tests: No Datalayer API token configured');
-        console.log('         Set DATALAYER_API_TOKEN env var or DATALAYER_TEST_TOKEN in .env.test');
-        return;
-    }
-    // Get token and base URL from test config
-    DATALAYER_TOKEN = testConfig.getToken();
-    BASE_URL = testConfig.getBaseUrl('IAM');
-    debugLog('Test configuration loaded');
-    debugLog('Base URL:', BASE_URL);
-    debugLog('Token available:', !!DATALAYER_TOKEN);
-    // Login to get a session token for profile tests
-    try {
-        const loginResponse = await authentication.login({
-            token: DATALAYER_TOKEN,
-        });
-        SESSION_TOKEN = loginResponse.token;
-        debugLog('Successfully logged in, got session token');
-    }
-    catch (error) {
-        console.error('Failed to login for profile tests:', error);
-        throw error;
-    }
-});
-describe.skipIf(skipTests)('IAM Profile Integration Tests', () => {
-    describe('me', () => {
-        it('should successfully get current user profile with token', async () => {
-            console.log('Testing /me endpoint with session token...');
-            const response = await profile.me(SESSION_TOKEN, BASE_URL);
-            console.log('Profile response:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(typeof response.message).toBe('string');
-            // Verify me object structure
-            expect(response.me).toBeDefined();
-            expect(response.me.id).toBeDefined();
-            expect(typeof response.me.id).toBe('string');
-            expect(response.me.uid).toBeDefined();
-            expect(typeof response.me.uid).toBe('string');
-            expect(response.me.handle).toBeDefined();
-            expect(typeof response.me.handle).toBe('string');
-            expect(response.me.email).toBeDefined();
-            expect(typeof response.me.email).toBe('string');
-            expect(response.me.firstName).toBeDefined();
-            expect(typeof response.me.firstName).toBe('string');
-            expect(response.me.lastName).toBeDefined();
-            expect(typeof response.me.lastName).toBe('string');
-            expect(response.me.avatarUrl).toBeDefined();
-            expect(typeof response.me.avatarUrl).toBe('string');
-            expect(response.me.roles).toBeDefined();
-            expect(Array.isArray(response.me.roles)).toBe(true);
-            console.log('Successfully retrieved user profile');
-            console.log('ID:', response.me.id);
-            console.log('UID:', response.me.uid);
-            console.log('Email:', response.me.email);
-            console.log('Handle:', response.me.handle);
-            console.log('Name:', response.me.firstName, response.me.lastName);
-            console.log('Roles:', response.me.roles.join(', '));
-        });
-        it('should successfully get current user profile using default URL', async () => {
-            console.log('Testing /me endpoint with default URL...');
-            const response = await profile.me(SESSION_TOKEN);
-            console.log('Profile response with default URL:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.me).toBeDefined();
-            expect(response.me.uid).toBeDefined();
-            expect(response.me.handle).toBeDefined();
-            expect(response.me.email).toBeDefined();
-            expect(Array.isArray(response.me.roles)).toBe(true);
-            console.log('Successfully retrieved user profile with default URL');
-            console.log('UID:', response.me.uid);
-            console.log('Handle:', response.me.handle);
-        });
-        it('should fail when using invalid token', async () => {
-            console.log('Testing /me endpoint with invalid token...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                await profile.me(invalidToken, BASE_URL);
-                // If we get here, the API accepted an invalid token (shouldn't happen)
-                throw new Error('Expected API to reject invalid token');
-            }
-            catch (error) {
-                console.log('API correctly rejected invalid token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // The error message should indicate server error or authentication failure
-                expect(error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('credentials') ||
-                    error.message.includes('Server Error') ||
-                    error.message.includes('500')).toBe(true);
-            }
-        });
-        it('should fail when no token is provided', async () => {
-            console.log('Testing /me endpoint without token...');
-            try {
-                // @ts-expect-error Testing missing required parameter
-                await profile.me();
-                // Should not reach here
-                throw new Error('Expected function to throw for missing token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request without token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-        it('should fail when empty token is provided', async () => {
-            console.log('Testing /me endpoint with empty token...');
-            try {
-                await profile.me('', BASE_URL);
-                // Should not reach here
-                throw new Error('Expected function to throw for empty token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request with empty token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-    });
-    describe('whoami', () => {
-        it('should successfully get current user identity with token', async () => {
-            console.log('Testing /whoami endpoint with session token...');
-            const response = await profile.whoami(SESSION_TOKEN, BASE_URL);
-            console.log('WhoAmI response:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(typeof response.message).toBe('string');
-            // Verify profile object structure
-            expect(response.profile).toBeDefined();
-            expect(response.profile.id).toBeDefined();
-            expect(typeof response.profile.id).toBe('string');
-            expect(response.profile.uid).toBeDefined();
-            expect(typeof response.profile.uid).toBe('string');
-            expect(response.profile.handle_s).toBeDefined();
-            expect(typeof response.profile.handle_s).toBe('string');
-            expect(response.profile.email_s).toBeDefined();
-            expect(typeof response.profile.email_s).toBe('string');
-            expect(response.profile.first_name_t).toBeDefined();
-            expect(typeof response.profile.first_name_t).toBe('string');
-            expect(response.profile.last_name_t).toBeDefined();
-            expect(typeof response.profile.last_name_t).toBe('string');
-            expect(response.profile.type_s).toBeDefined();
-            expect(typeof response.profile.type_s).toBe('string');
-            expect(response.profile.origin_s).toBeDefined();
-            expect(typeof response.profile.origin_s).toBe('string');
-            expect(response.profile.creation_ts_dt).toBeDefined();
-            expect(typeof response.profile.creation_ts_dt).toBe('string');
-            expect(response.profile.last_update_ts_dt).toBeDefined();
-            expect(typeof response.profile.last_update_ts_dt).toBe('string');
-            expect(response.profile.join_ts_dt).toBeDefined();
-            expect(typeof response.profile.join_ts_dt).toBe('string');
-            // join_request_ts_dt can be null
-            if (response.profile.join_request_ts_dt !== null) {
-                expect(typeof response.profile.join_request_ts_dt).toBe('string');
-            }
-            console.log('Successfully retrieved user identity');
-            console.log('ID:', response.profile.id);
-            console.log('UID:', response.profile.uid);
-            console.log('Email:', response.profile.email_s);
-            console.log('Handle:', response.profile.handle_s);
-            console.log('Name:', response.profile.first_name_t, response.profile.last_name_t);
-            console.log('Type:', response.profile.type_s);
-        });
-        it('should successfully get current user identity using default URL', async () => {
-            console.log('Testing /whoami endpoint with default URL...');
-            const response = await profile.whoami(SESSION_TOKEN);
-            console.log('WhoAmI response with default URL:', JSON.stringify(response, null, 2));
-            // Verify response structure
-            expect(response).toBeDefined();
-            expect(response.success).toBe(true);
-            expect(response.message).toBeDefined();
-            expect(response.profile).toBeDefined();
-            expect(response.profile.uid).toBeDefined();
-            expect(response.profile.handle_s).toBeDefined();
-            expect(response.profile.email_s).toBeDefined();
-            console.log('Successfully retrieved user identity with default URL');
-            console.log('UID:', response.profile.uid);
-            console.log('Handle:', response.profile.handle_s);
-        });
-        it('should fail whoami when using invalid token', async () => {
-            console.log('Testing /whoami endpoint with invalid token...');
-            const invalidToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJpbnZhbGlkIiwiaWF0IjoxNTE2MjM5MDIyfQ.invalid_signature_here';
-            try {
-                await profile.whoami(invalidToken, BASE_URL);
-                // If we get here, the API accepted an invalid token (shouldn't happen)
-                throw new Error('Expected API to reject invalid token');
-            }
-            catch (error) {
-                console.log('API correctly rejected invalid token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBeDefined();
-                // The error message should indicate server error or authentication failure
-                expect(error.message.includes('401') ||
-                    error.message.includes('Unauthorized') ||
-                    error.message.includes('Invalid') ||
-                    error.message.includes('credentials') ||
-                    error.message.includes('Server Error') ||
-                    error.message.includes('500')).toBe(true);
-            }
-        });
-        it('should fail whoami when no token is provided', async () => {
-            console.log('Testing /whoami endpoint without token...');
-            try {
-                // @ts-expect-error Testing missing required parameter
-                await profile.whoami();
-                // Should not reach here
-                throw new Error('Expected function to throw for missing token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request without token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-        it('should fail whoami when empty token is provided', async () => {
-            console.log('Testing /whoami endpoint with empty token...');
-            try {
-                await profile.whoami('', BASE_URL);
-                // Should not reach here
-                throw new Error('Expected function to throw for empty token');
-            }
-            catch (error) {
-                console.log('Correctly rejected request with empty token:', error.message);
-                expect(error).toBeDefined();
-                expect(error.message).toBe('Authentication token is required');
-            }
-        });
-    });
-});

package/lib/api/__tests__/runtimes.environments.integration.test.d.ts

@@ -1 +0,0 @@
-export {};