@sudobility/testomniac_client 0.0.100 → 0.0.102

package/dist/network/TestomniacClient.js

@@ -1,499 +1,280 @@
-import { buildUrl, createAuthHeaders } from '../utils/starter-helpers';
 const SCRIPT_PATHS = {
     interaction: id => `/api/v1/test-interactions/${id}/script`,
     surface: id => `/api/v1/test-surfaces/${id}/script`,
     sequence: id => `/api/v1/test-scenarios/sequences/${id}/script`,
     finding: id => `/api/v1/test-run-findings/${id}/script`,
 };
-function validateResponse(data, operation) {
-    if (data != null &&
-        typeof data === 'object' &&
-        'success' in data &&
-        typeof data.success === 'boolean') {
-        return data;
-    }
-    throw new Error(`Invalid API response for ${operation}: response does not match expected BaseResponse shape`);
-}
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    Accept: 'application/json',
+};
 export class TestomniacClient {
-    constructor(config) {
-        this.baseUrl = config.baseUrl;
-        this.networkClient = config.networkClient;
-    }
-    async getUser(userId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/users/${userId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
+    constructor(networkClient, baseUrl) {
+        this.networkClient = networkClient;
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+    }
+    async request(endpoint, options = {}) {
+        const url = `${this.baseUrl}${endpoint}`;
+        const requestHeaders = {
+            ...DEFAULT_HEADERS,
+            ...options.headers,
+        };
+        if (options.token) {
+            requestHeaders['Authorization'] = `Bearer ${options.token}`;
+        }
+        const requestOptions = {
+            method: options.method || 'GET',
+            headers: requestHeaders,
+        };
+        if (options.body !== undefined &&
+            options.method &&
+            options.method !== 'GET') {
+            requestOptions.body = JSON.stringify(options.body);
+        }
+        if (options.timeout) {
+            requestOptions.timeout = options.timeout;
+        }
+        const response = await this.networkClient.request(url, requestOptions);
+        if (response.data === undefined) {
+            throw new Error('No data received from server');
+        }
+        return response.data;
+    }
+    async getUser(token, userId) {
+        return this.request(`/api/v1/users/${userId}`, {
+            token,
         });
-        return validateResponse(response.data, 'getUser');
     }
     async getEntities(token) {
-        const url = buildUrl(this.baseUrl, '/api/v1/entities');
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
+        return this.request('/api/v1/entities', {
+            token,
         });
-        return validateResponse(response.data, 'getEntities');
     }
     async submitDiscoveryRun(data) {
-        const url = buildUrl(this.baseUrl, '/api/v1/scan');
-        const response = await this.networkClient.post(url, data);
-        return validateResponse(response.data, 'submitDiscoveryRun');
-    }
-    async submitDiscoveryRunAuthenticated(data, token) {
-        const url = buildUrl(this.baseUrl, '/api/v1/scan');
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'submitDiscoveryRunAuthenticated');
+        return this.request('/api/v1/scan', { method: 'POST', body: data });
     }
-    async getEntityProducts(entitySlug, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/products`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEntityProducts');
+    async submitDiscoveryRunAuthenticated(token, data) {
+        return this.request('/api/v1/scan', { method: 'POST', body: data, token });
     }
-    async createProduct(data, token) {
-        const url = buildUrl(this.baseUrl, '/api/v1/products');
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createProduct');
+    async getEntityProducts(token, entitySlug) {
+        return this.request(`/api/v1/entities/${entitySlug}/products`, { token });
     }
-    async createRunner(productId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/products/${productId}/runners`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
+    async createProduct(token, data) {
+        return this.request('/api/v1/products', {
+            method: 'POST',
+            body: data,
+            token,
         });
-        return validateResponse(response.data, 'createRunner');
     }
-    async getProduct(productId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/products/${productId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getProduct');
+    async resolveTestEnvironment(token, data) {
+        return this.request('/api/v1/test-environments/resolve', { method: 'POST', body: data, token });
     }
-    async getProductRuns(productId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/products/${productId}/runs`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getProductRuns');
+    async getEnvironmentUserData(token, environmentId) {
+        return this.request(`/api/v1/test-environments/${environmentId}/user-data`, { token });
     }
-    async getTestRun(testRunId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${testRunId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestRun');
+    async updateEnvironmentUserData(token, environmentId, data) {
+        return this.request(`/api/v1/test-environments/${environmentId}/user-data`, { method: 'PUT', body: { data }, token });
     }
-    async getRunSummary(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/summary`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
+    async endScan(token, data) {
+        return this.request('/api/v1/scan/end', {
+            method: 'POST',
+            body: data,
+            token,
         });
-        return validateResponse(response.data, 'getRunSummary');
     }
-    async getRunNavigationMap(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/navigation-map`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunNavigationMap');
+    async createRunner(token, productId, data) {
+        return this.request(`/api/v1/products/${productId}/runners`, { method: 'POST', body: data, token });
     }
-    async getRunStructure(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/structure`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunStructure');
+    async getProduct(token, productId) {
+        return this.request(`/api/v1/products/${productId}`, { token });
     }
-    async getRunLiveDashboard(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/live-dashboard`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunLiveDashboard');
+    async resolveProductByUrl(token, entityId, url) {
+        const query = new URLSearchParams({ entityId, url }).toString();
+        return this.request(`/api/v1/products/resolve-by-url?${query}`, { token });
     }
-    async getRunPages(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/pages`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunPages');
+    async getProductRuns(token, productId) {
+        return this.request(`/api/v1/products/${productId}/runs`, { token });
     }
-    async getRunPagesSummary(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/pages-summary`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunPagesSummary');
+    async getTestRun(token, testRunId) {
+        return this.request(`/api/v1/runs/${testRunId}`, { token });
     }
-    async getRunPageSummary(runId, pageId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/pages/${pageId}/summary`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunPageSummary');
+    async getRunSummary(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/summary`, { token });
     }
-    async getRunFindings(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/findings`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunFindings');
+    async getRunNavigationMap(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/navigation-map`, { token });
     }
-    async getRunTestInteractions(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/test-interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunTestInteractions');
+    async getRunStructure(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/structure`, { token });
     }
-    async getTestRunChildRuns(testRunId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${testRunId}/child-runs`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestRunChildRuns');
+    async getRunLiveDashboard(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/live-dashboard`, { token });
     }
-    async getRunPersonas(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/personas`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunPersonas');
+    async getRunPages(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/pages`, { token });
     }
-    async getRunScaffolds(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/scaffolds`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunScaffolds');
+    async getRunPagesSummary(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/pages-summary`, { token });
     }
-    async getRunPatterns(runId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runs/${runId}/patterns`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunPatterns');
+    async getRunPageSummary(token, runId, pageId) {
+        return this.request(`/api/v1/runs/${runId}/pages/${pageId}/summary`, { token });
     }
-    async getProductRunners(productId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/products/${productId}/runners`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getProductRunners');
+    async getRunFindings(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/findings`, { token });
     }
-    async getRunner(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunner');
+    async getRunTestInteractions(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/test-interactions`, { token });
     }
-    async getRunnerPages(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/pages`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerPages');
+    async getTestRunChildRuns(token, testRunId) {
+        return this.request(`/api/v1/runs/${testRunId}/child-runs`, { token });
     }
-    async getRunnerPageStates(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/page-states`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerPageStates');
+    async getRunPersonas(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/personas`, { token });
     }
-    async getRunnerTestInteractions(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerTestInteractions');
+    async getRunScaffolds(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/scaffolds`, { token });
     }
-    async getRunnerTestRuns(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-runs`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerTestRuns');
+    async getRunPatterns(token, runId) {
+        return this.request(`/api/v1/runs/${runId}/patterns`, { token });
     }
-    async getRunnerScaffolds(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/scaffolds`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerScaffolds');
+    async getProductRunners(token, productId) {
+        return this.request(`/api/v1/products/${productId}/runners`, { token });
     }
-    async getRunnerPersonas(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/personas`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerPersonas');
+    async getRunner(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}`, { token });
     }
-    async getRunnerTestSurfaceBundles(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerTestSurfaceBundles');
+    async getRunnerPages(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/pages`, { token });
     }
-    async getBundleSurfaces(runnerId, bundleId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getBundleSurfaces');
+    async getRunnerPageStates(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/page-states`, { token });
     }
-    async getBundleInteractions(runnerId, bundleId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getBundleInteractions');
+    async getRunnerTestInteractions(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-interactions`, { token });
     }
-    async getBundleScenarios(runnerId, bundleId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getBundleScenarios');
+    async getRunnerTestRuns(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-runs`, { token });
     }
-    async createTestSurfaceBundle(runnerId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createTestSurfaceBundle');
+    async getRunnerScaffolds(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/scaffolds`, { token });
     }
-    async updateTestSurfaceBundle(runnerId, bundleId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}`);
-        const response = await this.networkClient.put(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'updateTestSurfaceBundle');
+    async getRunnerPersonas(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/personas`, { token });
     }
-    async deleteTestSurfaceBundle(runnerId, bundleId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'deleteTestSurfaceBundle');
+    async getRunnerTestSurfaceBundles(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles`, { token });
     }
-    async addSurfaceToBundle(runnerId, bundleId, testSurfaceId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces`);
-        const response = await this.networkClient.post(url, { testSurfaceId }, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'addSurfaceToBundle');
+    async getBundleSurfaces(token, runnerId, bundleId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces`, { token });
     }
-    async addInteractionToBundle(runnerId, bundleId, testInteractionId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions`);
-        const response = await this.networkClient.post(url, { testInteractionId }, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'addInteractionToBundle');
+    async getBundleInteractions(token, runnerId, bundleId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions`, { token });
     }
-    async addScenarioToBundle(runnerId, bundleId, testScenarioId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios`);
-        const response = await this.networkClient.post(url, { testScenarioId }, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'addScenarioToBundle');
+    async getBundleScenarios(token, runnerId, bundleId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios`, { token });
     }
-    async removeSurfaceFromBundle(runnerId, bundleId, surfaceId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces/${surfaceId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'removeSurfaceFromBundle');
+    async createTestSurfaceBundle(token, runnerId, data) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles`, { method: 'POST', body: data, token });
     }
-    async removeInteractionFromBundle(runnerId, bundleId, interactionId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions/${interactionId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'removeInteractionFromBundle');
+    async updateTestSurfaceBundle(token, runnerId, bundleId, data) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}`, { method: 'PUT', body: data, token });
     }
-    async removeScenarioFromBundle(runnerId, bundleId, scenarioId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios/${scenarioId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'removeScenarioFromBundle');
+    async deleteTestSurfaceBundle(token, runnerId, bundleId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}`, { method: 'DELETE', token });
     }
-    async getRunnerSchedules(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-schedules`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerSchedules');
+    async addSurfaceToBundle(token, runnerId, bundleId, testSurfaceId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces`, { method: 'POST', body: { testSurfaceId }, token });
     }
-    async createTestSchedule(runnerId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-schedules`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createTestSchedule');
+    async addInteractionToBundle(token, runnerId, bundleId, testInteractionId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions`, { method: 'POST', body: { testInteractionId }, token });
     }
-    async getPageStates(pageId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/pages/${pageId}/states`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getPageStates');
+    async addScenarioToBundle(token, runnerId, bundleId, testScenarioId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios`, { method: 'POST', body: { testScenarioId }, token });
     }
-    async getPageStateItems(pageStateId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/pages/states/${pageStateId}/items`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getPageStateItems');
+    async removeSurfaceFromBundle(token, runnerId, bundleId, surfaceId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/surfaces/${surfaceId}`, { method: 'DELETE', token });
     }
-    async getPageStateScaffolds(pageStateId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/page-details/page-states/${pageStateId}/scaffolds`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getPageStateScaffolds');
+    async removeInteractionFromBundle(token, runnerId, bundleId, interactionId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/interactions/${interactionId}`, { method: 'DELETE', token });
     }
-    async getHtmlElement(id, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/page-details/html-elements/${id}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getHtmlElement');
+    async removeScenarioFromBundle(token, runnerId, bundleId, scenarioId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surface-bundles/${bundleId}/scenarios/${scenarioId}`, { method: 'DELETE', token });
     }
-    async getPersonaUseCases(personaId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas/${personaId}/use-cases`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getPersonaUseCases');
+    async getRunnerSchedules(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-schedules`, { token });
     }
-    async getUseCaseInputValues(useCaseId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas/use-cases/${useCaseId}/input-values`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getUseCaseInputValues');
+    async createTestSchedule(token, runnerId, data) {
+        return this.request(`/api/v1/runners/${runnerId}/test-schedules`, { method: 'POST', body: data, token });
     }
-    async getRunnerTestSurfaces(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-surfaces`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerTestSurfaces');
+    async getPageStates(token, pageId) {
+        return this.request(`/api/v1/pages/${pageId}/states`, { token });
     }
-    async getTestSurfaceTestInteractions(testSurfaceId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-surfaces/${testSurfaceId}/interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestSurfaceTestInteractions');
+    async getPageStateItems(token, pageStateId) {
+        return this.request(`/api/v1/pages/states/${pageStateId}/items`, { token });
     }
-    async getTestInteractionActions(testInteractionId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-interactions/${testInteractionId}/actions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestInteractionActions');
+    async getPageStateScaffolds(token, pageStateId) {
+        return this.request(`/api/v1/page-details/page-states/${pageStateId}/scaffolds`, { token });
     }
-    async getTestInteractionRunFindings(testInteractionRunId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-interaction-runs/${testInteractionRunId}/findings`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestInteractionRunFindings');
+    async getHtmlElement(token, id) {
+        return this.request(`/api/v1/page-details/html-elements/${id}`, { token });
     }
-    async getTestInteractionRun(testInteractionRunId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-interaction-runs/${testInteractionRunId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestInteractionRun');
+    async getPersonaUseCases(token, personaId) {
+        return this.request(`/api/v1/personas/${personaId}/use-cases`, { token });
     }
-    async getRunnerFindings(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/findings`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerFindings');
+    async getUseCaseInputValues(token, useCaseId) {
+        return this.request(`/api/v1/personas/use-cases/${useCaseId}/input-values`, { token });
     }
-    async getRunnerTestScenarios(runnerId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-scenarios`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getRunnerTestScenarios');
+    async getRunnerTestSurfaces(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-surfaces`, { token });
     }
-    async createTestScenario(runnerId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-scenarios`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createTestScenario');
+    async getTestSurfaceTestInteractions(token, testSurfaceId) {
+        return this.request(`/api/v1/test-surfaces/${testSurfaceId}/interactions`, { token });
     }
-    async updateTestScenario(runnerId, scenarioId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-scenarios/${scenarioId}`);
-        const response = await this.networkClient.put(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'updateTestScenario');
+    async getTestInteractionActions(token, testInteractionId) {
+        return this.request(`/api/v1/test-interactions/${testInteractionId}/actions`, { token });
     }
-    async deleteTestScenario(runnerId, scenarioId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/runners/${runnerId}/test-scenarios/${scenarioId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'deleteTestScenario');
+    async getTestInteractionRunFindings(token, testInteractionRunId) {
+        return this.request(`/api/v1/test-interaction-runs/${testInteractionRunId}/findings`, { token });
     }
-    async getTestScenarioSequences(scenarioId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-scenarios/${scenarioId}/sequences`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestScenarioSequences');
+    async getTestInteractionRun(token, testInteractionRunId) {
+        return this.request(`/api/v1/test-interaction-runs/${testInteractionRunId}`, { token });
     }
-    async getTestScenarioSequenceTestInteractions(sequenceId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-scenarios/sequences/${sequenceId}/test-interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestScenarioSequenceTestInteractions');
+    async getRunnerFindings(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/findings`, { token });
     }
-    async getTestScenarioSequenceRuns(sequenceId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-scenarios/sequences/${sequenceId}/runs`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getTestScenarioSequenceRuns');
+    async getRunnerTestScenarios(token, runnerId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-scenarios`, { token });
     }
-    async getProductEnvironments(productId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/products/${productId}/environments`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getProductEnvironments');
+    async createTestScenario(token, runnerId, data) {
+        return this.request(`/api/v1/runners/${runnerId}/test-scenarios`, { method: 'POST', body: data, token });
     }
-    async getEnvironmentPages(envId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-environments/${envId}/pages`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEnvironmentPages');
+    async updateTestScenario(token, runnerId, scenarioId, data) {
+        return this.request(`/api/v1/runners/${runnerId}/test-scenarios/${scenarioId}`, { method: 'PUT', body: data, token });
+    }
+    async deleteTestScenario(token, runnerId, scenarioId) {
+        return this.request(`/api/v1/runners/${runnerId}/test-scenarios/${scenarioId}`, { method: 'DELETE', token });
+    }
+    async getTestScenarioSequences(token, scenarioId) {
+        return this.request(`/api/v1/test-scenarios/${scenarioId}/sequences`, { token });
     }
-    async getEnvironmentTestInteractions(envId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-environments/${envId}/test-interactions`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
+    async getTestScenarioSequenceTestInteractions(token, sequenceId) {
+        return this.request(`/api/v1/test-scenarios/sequences/${sequenceId}/test-interactions`, {
+            token,
         });
-        return validateResponse(response.data, 'getEnvironmentTestInteractions');
     }
-    async getEnvironmentTestInteractionsPage(envId, params, token) {
+    async getTestScenarioSequenceRuns(token, sequenceId) {
+        return this.request(`/api/v1/test-scenarios/sequences/${sequenceId}/runs`, { token });
+    }
+    async getProductEnvironments(token, productId) {
+        return this.request(`/api/v1/products/${productId}/environments`, { token });
+    }
+    async getEnvironmentPages(token, envId) {
+        return this.request(`/api/v1/test-environments/${envId}/pages`, { token });
+    }
+    async getEnvironmentTestInteractions(token, envId) {
+        return this.request(`/api/v1/test-environments/${envId}/test-interactions`, { token });
+    }
+    async getEnvironmentTestInteractionsPage(token, envId, params) {
         const qs = new URLSearchParams();
         qs.set('limit', String(params.limit));
         qs.set('offset', String(params.offset));
@@ -505,140 +286,67 @@ export class TestomniacClient {
             qs.set('sizeClass', params.sizeClass);
         if (params.search)
             qs.set('search', params.search);
-        const url = `${buildUrl(this.baseUrl, `/api/v1/test-environments/${envId}/test-interactions/page`)}?${qs.toString()}`;
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEnvironmentTestInteractionsPage');
+        return this.request(`/api/v1/test-environments/${envId}/test-interactions/page?${qs.toString()}`, { token });
     }
-    async getEnvironmentTestSurfaces(envId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-environments/${envId}/test-surfaces`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEnvironmentTestSurfaces');
+    async getEnvironmentTestSurfaces(token, envId) {
+        return this.request(`/api/v1/test-environments/${envId}/test-surfaces`, { token });
     }
-    async createTestInteractionRun(data, token) {
-        const url = buildUrl(this.baseUrl, '/api/v1/test-interaction-runs');
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createTestInteractionRun');
+    async createTestInteractionRun(token, data) {
+        return this.request('/api/v1/test-interaction-runs', { method: 'POST', body: data, token });
     }
-    async clearSupersededFindings(testInteractionRunId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-interaction-runs/${testInteractionRunId}/superseded-findings`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'clearSupersededFindings');
+    async clearSupersededFindings(token, testInteractionRunId) {
+        return this.request(`/api/v1/test-interaction-runs/${testInteractionRunId}/superseded-findings`, { method: 'DELETE', token });
     }
-    async getEntityCredentials(entitySlug, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/credentials`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEntityCredentials');
+    async getEntityCredentials(token, entitySlug) {
+        return this.request(`/api/v1/entities/${entitySlug}/credentials`, { token });
     }
-    async createEntityCredential(entitySlug, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/credentials`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createEntityCredential');
+    async createEntityCredential(token, entitySlug, data) {
+        return this.request(`/api/v1/entities/${entitySlug}/credentials`, { method: 'POST', body: data, token });
     }
-    async updateEntityCredential(entitySlug, credentialId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/credentials/${credentialId}`);
-        const response = await this.networkClient.put(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'updateEntityCredential');
+    async updateEntityCredential(token, entitySlug, credentialId, data) {
+        return this.request(`/api/v1/entities/${entitySlug}/credentials/${credentialId}`, { method: 'PUT', body: data, token });
     }
-    async deleteEntityCredential(entitySlug, credentialId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/credentials/${credentialId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'deleteEntityCredential');
+    async deleteEntityCredential(token, entitySlug, credentialId) {
+        return this.request(`/api/v1/entities/${entitySlug}/credentials/${credentialId}`, { method: 'DELETE', token });
     }
-    async getEntityApiKeys(entitySlug, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/api-keys`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getEntityApiKeys');
+    async getEntityApiKeys(token, entitySlug) {
+        return this.request(`/api/v1/entities/${entitySlug}/api-keys`, { token });
     }
-    async createEntityApiKey(entitySlug, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/api-keys`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'createEntityApiKey');
+    async createEntityApiKey(token, entitySlug, data) {
+        return this.request(`/api/v1/entities/${entitySlug}/api-keys`, { method: 'POST', body: data, token });
     }
-    async deleteEntityApiKey(entitySlug, apiKeyId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/entities/${entitySlug}/api-keys/${apiKeyId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'deleteEntityApiKey');
+    async deleteEntityApiKey(token, entitySlug, apiKeyId) {
+        return this.request(`/api/v1/entities/${entitySlug}/api-keys/${apiKeyId}`, { method: 'DELETE', token });
     }
-    async getObjectScript(kind, id, token) {
-        const url = buildUrl(this.baseUrl, SCRIPT_PATHS[kind](id));
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        if (!response.ok || !response.success || !response.data) {
-            throw new Error(response.error || `Failed to load script (HTTP ${response.status})`);
-        }
-        return response.data.script;
+    async getObjectScript(token, kind, id) {
+        const response = await this.request(SCRIPT_PATHS[kind](id), { token });
+        return response.script;
     }
-    async getProductPersonas(productId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas?productId=${productId}`);
-        const response = await this.networkClient.get(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'getProductPersonas');
+    async getProductPersonas(token, productId) {
+        return this.request(`/api/v1/personas?productId=${productId}`, { token });
     }
-    async createPersona(data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
+    async createPersona(token, data) {
+        return this.request('/api/v1/personas', {
+            method: 'POST',
+            body: data,
+            token,
         });
-        return validateResponse(response.data, 'createPersona');
     }
-    async updatePersona(personaId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas/${personaId}`);
-        const response = await this.networkClient.put(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'updatePersona');
+    async updatePersona(token, personaId, data) {
+        return this.request(`/api/v1/personas/${personaId}`, { method: 'PUT', body: data, token });
     }
-    async deletePersona(personaId, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas/${personaId}`);
-        const response = await this.networkClient.delete(url, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'deletePersona');
+    async deletePersona(token, personaId) {
+        return this.request(`/api/v1/personas/${personaId}`, { method: 'DELETE', token });
     }
-    async detectPersonas(data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/personas/detect`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'detectPersonas');
+    async detectPersonas(token, data) {
+        return this.request('/api/v1/personas/detect', { method: 'POST', body: data, token });
     }
-    async detectTestScenarios(data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-scenarios/detect`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'detectTestScenarios');
+    async detectTestScenarios(token, data) {
+        return this.request('/api/v1/test-scenarios/detect', { method: 'POST', body: data, token });
     }
-    async generateSequence(scenarioId, data, token) {
-        const url = buildUrl(this.baseUrl, `/api/v1/test-scenarios/${scenarioId}/generate-sequence`);
-        const response = await this.networkClient.post(url, data, {
-            headers: createAuthHeaders(token),
-        });
-        return validateResponse(response.data, 'generateSequence');
+    async generateSequence(token, scenarioId, data) {
+        return this.request(`/api/v1/test-scenarios/${scenarioId}/generate-sequence`, { method: 'POST', body: data, token });
     }
 }
+export const createTestomniacClient = (networkClient, baseUrl) => new TestomniacClient(networkClient, baseUrl);
 //# sourceMappingURL=TestomniacClient.js.map