@vizzly/api-client 0.0.16 → 0.0.19

package/dist/models/DashboardManager.d.ts

@@ -1,17 +1,17 @@
 import { Vizzly } from './Vizzly';
-import { CreateDashboardParams, Dashboard, DashboardDefinition, Dashboard as DashboardType, GlobalLibrary, UpdateDashboardParams } from '../types';
+import { CreateDashboardParams, Dashboard, DashboardDefinition, Dashboard as DashboardType, GlobalLibrary, RequestParams, UpdateDashboardParams } from '../types';
 export declare class DashboardManager {
     private vizzly;
     constructor(vizzly: Vizzly);
-    create(params: CreateDashboardParams): Promise<{
+    create(params: RequestParams<CreateDashboardParams>): Promise<{
         dashboard: Dashboard;
         permissions: import("../types").DashboardPermission[];
     }>;
-    update(params: Omit<UpdateDashboardParams, 'dashboardPermission' | 'definition'> & {
+    update(params: RequestParams<Omit<UpdateDashboardParams, 'dashboardPermission' | 'definition'> & {
         dashboardId: string;
         definition?: DashboardDefinition;
-    }): Promise<Dashboard>;
-    getDashboards(): Promise<DashboardType[]>;
+    }>): Promise<Dashboard>;
+    getDashboards(params?: RequestParams): Promise<DashboardType[]>;
     static mergeDashboardsAndGlobalLibraries(dashboards: DashboardType[], globalLibraries: GlobalLibrary[]): DashboardType[];
     static mergeCustomFields(dashboard: DashboardType, dashboards: DashboardType[], parentGlobalLibrariesForDashboard: GlobalLibrary[], childGlobalLibrariesForDashboard: GlobalLibrary[]): DashboardType['definition']['customFields'];
     static markViewsAsProtected(componentLibrary: DashboardType['definition']['componentLibrary']): DashboardType['definition']['componentLibrary'];

package/dist/models/DashboardManager.js

@@ -27,7 +27,10 @@ class DashboardManager {
             var _a, _b, _c;
             const dashboardRepository = this.vizzly.getDashboardRepository();
             const globalLibraryRepository = this.vizzly.getGlobalLibraryRepository();
-            const [{ global_libraries: globalLibraries, permissions: globalLibraryPermissions }, { dashboards, permissions: dashboardPermissions },] = yield Promise.all([globalLibraryRepository.fetchGlobalLibraries(), dashboardRepository.fetchDashboards()]);
+            const [{ global_libraries: globalLibraries, permissions: globalLibraryPermissions }, { dashboards, permissions: dashboardPermissions },] = yield Promise.all([
+                globalLibraryRepository.fetchGlobalLibraries(params),
+                dashboardRepository.fetchDashboards(params),
+            ]);
             const dashboardToUpdate = dashboards.find((dashboard) => dashboard.id === params.dashboardId);
             if (!dashboardToUpdate)
                 throw new Error('Cannot find dashboard to update.');
@@ -90,13 +93,13 @@ class DashboardManager {
             return updatedDashboard;
         });
     }
-    getDashboards() {
+    getDashboards(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const dashboardRepo = this.vizzly.getDashboardRepository();
             const libraryRepo = this.vizzly.getGlobalLibraryRepository();
             const [{ dashboards }, { global_libraries: globalLibraries }] = yield Promise.all([
-                dashboardRepo.fetchDashboards(),
-                libraryRepo.fetchGlobalLibraries(),
+                dashboardRepo.fetchDashboards(params),
+                libraryRepo.fetchGlobalLibraries(params),
             ]);
             return DashboardManager.mergeDashboardsAndGlobalLibraries(dashboards, globalLibraries);
         });
@@ -111,8 +114,6 @@ class DashboardManager {
             let { parentGlobalLibraries, childGlobalLibraries } = GlobalLibraryRepository_1.GlobalLibraryRepository.splitParentAndChildGlobalLibraries(globalLibraries);
             // Only include the child libraries if the dashboard is not a parent.
             childGlobalLibraries = dashboard.parent_dashboard_id === null ? [] : childGlobalLibraries;
-            // If parent dashboard, all libraries are for the parent.
-            // parentGlobalLibraries = dashboard.parent_dashboard_id === null ? [...parentGlobalLibraries, ...childGlobalLibraries] : [];
             // Add the views from the various sources together. The order does matter -
             // first elements are kept if a duplicate view is found.
             let newLibrary = (0, lodash_1.uniqBy)([

package/dist/models/DashboardRepository.d.ts

@@ -1,4 +1,4 @@
-import { CreateDashboardParams, Dashboard, DashboardFromAPI, DashboardPermission, UpdateDashboardParams } from '../types';
+import { CreateDashboardParams, Dashboard, DashboardFromAPI, DashboardPermission, RequestParams, UpdateDashboardParams } from '../types';
 import { Vizzly } from './Vizzly';
 export declare class DashboardRepository {
     private vizzly;
@@ -7,15 +7,15 @@ export declare class DashboardRepository {
         dashboard: Dashboard;
         permissions: DashboardPermission[];
     }>;
-    updateDashboard(params: UpdateDashboardParams): Promise<Dashboard>;
-    fetchDashboards(): Promise<{
+    updateDashboard(params: RequestParams<UpdateDashboardParams>): Promise<Dashboard>;
+    fetchDashboards(params?: RequestParams): Promise<{
         dashboards: Dashboard[];
         permissions: DashboardPermission[];
     }>;
     static embellishDashboardFromAPI(dashboard: DashboardFromAPI, permissions: DashboardPermission[]): Dashboard;
     static takeHighestPermission(dashboardId: string, permissions: DashboardPermission[]): DashboardPermission;
     static takePermissionsOfScope(dashboardId: string, permissions: DashboardPermission[], scope: 'read' | 'read_write'): DashboardPermission[];
-    fetchDashboardAccessTokens(): Promise<{
+    fetchDashboardAccessTokens(params?: RequestParams): Promise<{
         dashboards: Dashboard[];
         permissions: DashboardPermission[];
     }>;

package/dist/models/DashboardRepository.js

@@ -66,35 +66,9 @@ class DashboardRepository {
             throw new FailedToUpdateDashboard_1.FailedToUpdateDashboard(`Failed to update dashboard, got status ${updatedDashboard.status}`);
         });
     }
-    fetchDashboards() {
+    fetchDashboards(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.fetchDashboardAccessTokens();
-            // let dashboardResponse: Response<FetchDashboardsResponseBody>;
-            // if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
-            //   const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-            //   dashboardResponse = await vizzlyQueryEngineApi.execute<FetchDashboardsResponseBody>(
-            //     vizzlyQueryEngineApi.buildFetchDashboardsRequest(permissions.map((p) => p.token))
-            //   );
-            // } else {
-            //   const vizzlyApi = this.vizzly.getVizzlyAPI();
-            //   dashboardResponse = await vizzlyApi.execute<{ found: Dashboard[]; not_found: any[] }>(
-            //     vizzlyApi.buildFetchDashboardsRequest(permissions.map((p) => p.token))
-            //   );
-            // }
-            // if (dashboardResponse.status === 200) {
-            // dashboardResponse.body.found.forEach((dashboard) => {
-            //   if (typeof dashboard.definition === 'string') {
-            //     throw new FailedToDecryptDashboardBeforeClient();
-            //   }
-            // });
-            // return {
-            //   found: dashboardResponse.body.found.map((foundDashboard) =>
-            //     DashboardRepository.embellishDashboardFromAPI(foundDashboard, permissions)
-            //   ),
-            //   not_found: dashboardResponse.body.not_found,
-            // };
-            // }
-            // throw new FailedToFetchDashboards(`Failed to fetch dashboards. Got status code ${dashboardResponse.status}.`);
+            return yield this.fetchDashboardAccessTokens(params);
         });
     }
     static embellishDashboardFromAPI(dashboard, permissions) {
@@ -108,16 +82,16 @@ class DashboardRepository {
     static takePermissionsOfScope(dashboardId, permissions, scope) {
         return permissions.filter((p) => p.dashboardId === dashboardId && p.scope === scope);
     }
-    fetchDashboardAccessTokens() {
+    fetchDashboardAccessTokens(params) {
         return __awaiter(this, void 0, void 0, function* () {
             let accessTokens;
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                accessTokens = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardAccessTokensRequest());
+                accessTokens = yield vizzlyQueryEngineApi.execute(vizzlyQueryEngineApi.buildFetchDashboardAccessTokensRequest(params));
             }
             else {
                 const vizzlyApi = this.vizzly.getVizzlyAPI();
-                accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest());
+                accessTokens = yield vizzlyApi.execute(vizzlyApi.buildFetchDashboardAccessTokensRequest(params));
             }
             if (accessTokens.status === 200) {
                 const formattedPermissions = accessTokens.body.permissions.map(Permission_1.Permission.formatDashboardPermission);

package/dist/models/GlobalLibraryRepository.d.ts

@@ -1,4 +1,4 @@
-import { CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, Response, UpdateGlobalLibraryParams } from '../types';
+import { CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, RequestParams, Response, UpdateGlobalLibraryParams } from '../types';
 import { Vizzly } from './Vizzly';
 export declare class GlobalLibraryRepository {
     private vizzly;
@@ -8,11 +8,11 @@ export declare class GlobalLibraryRepository {
         global_library: GlobalLibrary;
         permissions: GlobalLibraryPermission[];
     }>;
-    fetchGlobalLibraries(): Promise<{
+    fetchGlobalLibraries(params?: RequestParams): Promise<{
         global_libraries: GlobalLibrary[];
         permissions: GlobalLibraryPermission[];
     }>;
-    fetchGlobalLibraryAccessTokens(): Promise<{
+    fetchGlobalLibraryAccessTokens(params?: RequestParams): Promise<{
         global_libraries: GlobalLibrary[];
         permissions: GlobalLibraryPermission[];
     }>;

package/dist/models/GlobalLibraryRepository.js

@@ -30,22 +30,22 @@ class GlobalLibraryRepository {
             }
         });
     }
-    fetchGlobalLibraries() {
+    fetchGlobalLibraries(params) {
         return __awaiter(this, void 0, void 0, function* () {
             // Now, we fetch the libraries and the access tokens from the access call.
-            return yield this.fetchGlobalLibraryAccessTokens();
+            return yield this.fetchGlobalLibraryAccessTokens(params);
         });
     }
-    fetchGlobalLibraryAccessTokens() {
+    fetchGlobalLibraryAccessTokens(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const vizzlyApi = this.vizzly.getVizzlyAPI();
             let accessTokens;
             if (this.vizzly.implementationStrategy.shouldPersistViaQueryEngine()) {
                 const vizzlyQueryEngineApi = this.vizzly.getVizzlyQueryEngineAPI();
-                accessTokens = yield vizzlyQueryEngineApi.fetchGlobalLibraryAccessTokens();
+                accessTokens = yield vizzlyQueryEngineApi.fetchGlobalLibraryAccessTokens(params);
             }
             else {
-                accessTokens = yield vizzlyApi.fetchGlobalLibraryAccessTokens();
+                accessTokens = yield vizzlyApi.fetchGlobalLibraryAccessTokens(params);
             }
             if (accessTokens.status === 200) {
                 return {

package/dist/models/VizzlyApi.d.ts

@@ -1,100 +1,102 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, Request, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
+import { CreateDashboardParams, CreateGlobalLibraryParams, GlobalLibrary, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, Request, RequestParams, UpdateDashboardParams, UpdateDashboardResponseBody, UpdateGlobalLibraryParams } from '../types';
 import { nVizzlyApi } from '../types';
 export declare class VizzlyApi extends Api {
     constructor(auth: Authentication, host?: string);
-    buildFetchDashboardAccessTokensRequest(): Request<{
+    buildFetchDashboardAccessTokensRequest(params?: RequestParams): Request<{
         projectAdminOverrideToken: string | undefined;
         dashboardAccessToken: string;
     }>;
-    fetchGlobalLibraries(params: {
+    fetchGlobalLibraries(params: RequestParams<{
         globalLibraryAccessTokens: string[];
-    }): Promise<import("../types").Response<{
+    }>): Promise<import("../types").Response<{
         found: GlobalLibrary[];
         not_found: string[];
     }>>;
-    buildFetchGlobalLibrariesRequest(params: {
+    buildFetchGlobalLibrariesRequest(params: RequestParams<{
         globalLibraryAccessTokens: string[];
-    }): Request<{
+    }>): Request<{
         globalLibraryAccessTokens: string[];
     }>;
-    fetchGlobalLibraryAccessTokens(): Promise<import("../types").Response<{
+    fetchGlobalLibraryAccessTokens(params?: RequestParams): Promise<import("../types").Response<{
         global_libraries: GlobalLibrary[];
         permissions: Array<GlobalLibraryPermissionFromAPI>;
     }>>;
-    buildFetchGlobalLibraryAccessTokensRequest(): Request<{
+    buildFetchGlobalLibraryAccessTokensRequest(params?: RequestParams): Request<{
         projectAdminOverrideToken: string | undefined;
         dashboardAccessToken: string;
     }>;
-    buildCreateDashboardRequest(params: CreateDashboardParams): Request<CreateDashboardParams & {
+    buildCreateDashboardRequest(params: RequestParams<CreateDashboardParams>): Request<CreateDashboardParams & {
         dashboardAccessToken: string;
     }>;
-    buildFetchDashboardsRequest(dashboardSessionAccessTokens: string[]): Request<{}>;
-    createParentDashboard(params: nVizzlyApi.CreateParentDashboardParams): Promise<import("../types").Response<unknown>>;
-    buildCreateParentDashboardRequest(params: nVizzlyApi.CreateParentDashboardParams): Request<{}>;
-    createParentGlobalLibrary(params: nVizzlyApi.CreateParentGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
-    buildCreateParentGlobalLibraryRequest(params: nVizzlyApi.CreateParentGlobalLibraryParams): Request<{}>;
-    createGlobalLibrary(params: CreateGlobalLibraryParams): Promise<{
+    buildFetchDashboardsRequest(params: RequestParams<{
+        dashboardSessionAccessTokens: string[];
+    }>): Request<{}>;
+    createParentDashboard(params: RequestParams<nVizzlyApi.CreateParentDashboardParams>): Promise<import("../types").Response<unknown>>;
+    buildCreateParentDashboardRequest(params: RequestParams<nVizzlyApi.CreateParentDashboardParams>): Request<{}>;
+    createParentGlobalLibrary(params: RequestParams<nVizzlyApi.CreateParentGlobalLibraryParams>): Promise<import("../types").Response<unknown>>;
+    buildCreateParentGlobalLibraryRequest(params: RequestParams<nVizzlyApi.CreateParentGlobalLibraryParams>): Request<{}>;
+    createGlobalLibrary(params: RequestParams<CreateGlobalLibraryParams>): Promise<{
         global_library: GlobalLibrary;
         permissions: Array<GlobalLibraryPermission>;
     }>;
-    buildCreateGlobalLibraryRequest(params: CreateGlobalLibraryParams): Request<{}>;
-    getProjects(): Promise<import("../types").Response<unknown>>;
-    buildGetProjectsRequest(): Request<{}>;
-    createProjectApiKey(params: nVizzlyApi.CreateProjectApiKeyParams): Promise<import("../types").Response<{
+    buildCreateGlobalLibraryRequest(params: RequestParams<CreateGlobalLibraryParams>): Request<{}>;
+    getProjects(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildGetProjectsRequest(params?: RequestParams): Request<{}>;
+    createProjectApiKey(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Promise<import("../types").Response<{
         api_key: string;
     }>>;
-    buildCreateProjectApiKeyRequest(params: nVizzlyApi.CreateProjectApiKeyParams): Request<{}>;
-    createQueryEngineUser(params: nVizzlyApi.CreateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
-    buildCreateQueryEngineUserRequest(params: nVizzlyApi.CreateQueryEngineUserParams): Request<{}>;
-    buildCreateSelfHostedDynamicQueryEngineProjectRequest(): Request<{}>;
-    buildCreateSelfHostedInBrowserProjectRequest(): Request<{}>;
-    buildCreateSelfHostedProjectRequest(): Request<{}>;
-    createManagedQueryEngineProject(): Promise<import("../types").Response<unknown>>;
-    buildCreateManagedQueryEngineProjectRequest(): Request<{}>;
-    createVizzlyConfigVersion(params: nVizzlyApi.CreateVizzlyConfigVersionParams): Promise<import("../types").Response<unknown>>;
-    buildCreateVizzlyConfigVersionRequest(params: nVizzlyApi.CreateVizzlyConfigVersionParams): Request<{}>;
-    duplicateParentDashboard(params: nVizzlyApi.DuplicateParentDashboardParams): Promise<import("../types").Response<unknown>>;
-    buildDuplicateParentDashboardRequest(params: nVizzlyApi.DuplicateParentDashboardParams): Request<{}>;
-    getConnection(params: nVizzlyApi.GetConnectionParams): Promise<{
+    buildCreateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.CreateProjectApiKeyParams>): Request<{}>;
+    createQueryEngineUser(params: RequestParams<nVizzlyApi.CreateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    buildCreateQueryEngineUserRequest(params: RequestParams<nVizzlyApi.CreateQueryEngineUserParams>): Request<{}>;
+    buildCreateSelfHostedDynamicQueryEngineProjectRequest(params?: RequestParams): Request<{}>;
+    buildCreateSelfHostedInBrowserProjectRequest(params?: RequestParams): Request<{}>;
+    buildCreateSelfHostedProjectRequest(params?: RequestParams): Request<{}>;
+    createManagedQueryEngineProject(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildCreateManagedQueryEngineProjectRequest(params?: RequestParams): Request<{}>;
+    createVizzlyConfigVersion(params: RequestParams<nVizzlyApi.CreateVizzlyConfigVersionParams>): Promise<import("../types").Response<unknown>>;
+    buildCreateVizzlyConfigVersionRequest(params: RequestParams<nVizzlyApi.CreateVizzlyConfigVersionParams>): Request<{}>;
+    duplicateParentDashboard(params: RequestParams<nVizzlyApi.DuplicateParentDashboardParams>): Promise<import("../types").Response<unknown>>;
+    buildDuplicateParentDashboardRequest(params: RequestParams<nVizzlyApi.DuplicateParentDashboardParams>): Request<{}>;
+    getConnection(params: RequestParams<nVizzlyApi.GetConnectionParams>): Promise<{
         encryptedCredentials: string | null;
     }>;
-    buildGetConnectionRequest(params: nVizzlyApi.GetConnectionParams): Request<{}>;
-    getManagedQueryEngineKeyPair(params: nVizzlyApi.GetManagedQueryEngineKeyPairParams): Promise<import("../types").Response<unknown>>;
-    buildGetManagedQueryEngineKeyPairRequest(params: nVizzlyApi.GetManagedQueryEngineKeyPairParams): Request<{}>;
-    getProject(params: nVizzlyApi.GetProjectParams): Promise<import("../types").Response<unknown>>;
-    buildGetProjectRequest(params: nVizzlyApi.GetProjectParams): Request<{}>;
-    getProjectAccessToken(params: nVizzlyApi.GetProjectAccessTokenParams): Promise<import("../types").Response<{
+    buildGetConnectionRequest(params: RequestParams<nVizzlyApi.GetConnectionParams>): Request<{}>;
+    getManagedQueryEngineKeyPair(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Promise<import("../types").Response<unknown>>;
+    buildGetManagedQueryEngineKeyPairRequest(params: RequestParams<nVizzlyApi.GetManagedQueryEngineKeyPairParams>): Request<{}>;
+    getProject(params: RequestParams<nVizzlyApi.GetProjectParams>): Promise<import("../types").Response<unknown>>;
+    buildGetProjectRequest(params: RequestParams<nVizzlyApi.GetProjectParams>): Request<{}>;
+    getProjectAccessToken(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Promise<import("../types").Response<{
         token: {
             max_age: number;
             token: string;
         };
     }>>;
-    buildGetProjectAccessTokenRequest(params: nVizzlyApi.GetProjectAccessTokenParams): Request<{}>;
-    getQueryEngineUser(params: nVizzlyApi.GetQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
-    buildGetQueryEngineUserRequest(params: nVizzlyApi.GetQueryEngineUserParams): Request<{}>;
-    getTeamMembers(params: nVizzlyApi.GetTeamMembers): Promise<import("../types").Response<unknown>>;
-    buildGetTeamMembersRequest(params: nVizzlyApi.GetTeamMembers): Request<{}>;
-    getVizzlyConfig(params: nVizzlyApi.GetVizzlyConfigParams): Promise<{
+    buildGetProjectAccessTokenRequest(params: RequestParams<nVizzlyApi.GetProjectAccessTokenParams>): Request<{}>;
+    getQueryEngineUser(params: RequestParams<nVizzlyApi.GetQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    buildGetQueryEngineUserRequest(params: RequestParams<nVizzlyApi.GetQueryEngineUserParams>): Request<{}>;
+    getTeamMembers(params: RequestParams<nVizzlyApi.GetTeamMembers>): Promise<import("../types").Response<unknown>>;
+    buildGetTeamMembersRequest(params: RequestParams<nVizzlyApi.GetTeamMembers>): Request<{}>;
+    getVizzlyConfig(params: RequestParams<nVizzlyApi.GetVizzlyConfigParams>): Promise<{
         encryptedConfig: string | null;
     }>;
-    buildGetVizzlyConfigRequest(params: nVizzlyApi.GetVizzlyConfigParams): Request<{}>;
-    saveConnection(params: nVizzlyApi.SaveConnectionParams): Promise<import("../types").Response<unknown>>;
-    buildSaveConnectionRequest(params: nVizzlyApi.SaveConnectionParams): Request<{}>;
-    buildSaveEncryptedProjectEncryptionSecretRequest(params: nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams): Request<{}>;
-    saveScheduledReport(params: nVizzlyApi.SaveScheduledReportParams): Promise<import("../types").Response<unknown>>;
-    buildSaveScheduledReportRequest(params: nVizzlyApi.SaveScheduledReportParams): Request<{}>;
-    updateDashboard(params: UpdateDashboardParams): Promise<import("../types").Response<UpdateDashboardResponseBody>>;
-    buildUpdateDashboardRequest(params: UpdateDashboardParams): Request<{}>;
-    updateParentGlobalLibrary(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Promise<import("../types").Response<unknown>>;
-    buildUpdateParentGlobalLibraryRequest(params: nVizzlyApi.UpdateParentGlobalLibraryParams): Request<{}>;
+    buildGetVizzlyConfigRequest(params: RequestParams<nVizzlyApi.GetVizzlyConfigParams>): Request<{}>;
+    saveConnection(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Promise<import("../types").Response<unknown>>;
+    buildSaveConnectionRequest(params: RequestParams<nVizzlyApi.SaveConnectionParams>): Request<{}>;
+    buildSaveEncryptedProjectEncryptionSecretRequest(params: RequestParams<nVizzlyApi.SaveEncryptedProjectEncryptionSecretParams>): Request<{}>;
+    saveScheduledReport(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Promise<import("../types").Response<unknown>>;
+    buildSaveScheduledReportRequest(params: RequestParams<nVizzlyApi.SaveScheduledReportParams>): Request<{}>;
+    updateDashboard(params: RequestParams<UpdateDashboardParams>): Promise<import("../types").Response<UpdateDashboardResponseBody>>;
+    buildUpdateDashboardRequest(params: RequestParams<UpdateDashboardParams>): Request<{}>;
+    updateParentGlobalLibrary(params: RequestParams<nVizzlyApi.UpdateParentGlobalLibraryParams>): Promise<import("../types").Response<unknown>>;
+    buildUpdateParentGlobalLibraryRequest(params: RequestParams<nVizzlyApi.UpdateParentGlobalLibraryParams>): Request<{}>;
     updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<{
         global_library: GlobalLibrary;
     }>>;
-    buildUpdateGlobalLibraryRequest(params: UpdateGlobalLibraryParams): Request<{}>;
-    updateProjectApiKey(params: nVizzlyApi.UpdateProjectApiKeyParams): Promise<import("../types").Response<unknown>>;
-    buildUpdateProjectApiKeyRequest(params: nVizzlyApi.UpdateProjectApiKeyParams): Request<{}>;
-    updateQueryEngineUser(params: nVizzlyApi.UpdateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
-    buildUpdateQueryEngineUserRequest(params: nVizzlyApi.UpdateQueryEngineUserParams): Request<{}>;
+    buildUpdateGlobalLibraryRequest(params: RequestParams<UpdateGlobalLibraryParams>): Request<{}>;
+    updateProjectApiKey(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Promise<import("../types").Response<unknown>>;
+    buildUpdateProjectApiKeyRequest(params: RequestParams<nVizzlyApi.UpdateProjectApiKeyParams>): Request<{}>;
+    updateQueryEngineUser(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    buildUpdateQueryEngineUserRequest(params: RequestParams<nVizzlyApi.UpdateQueryEngineUserParams>): Request<{}>;
 }

package/dist/models/VizzlyApi.js

@@ -19,7 +19,7 @@ class VizzlyApi extends Api_1.Api {
     constructor(auth, host = 'https://api.vizzly.co') {
         super(auth, host);
     }
-    buildFetchDashboardAccessTokensRequest() {
+    buildFetchDashboardAccessTokensRequest(params) {
         return {
             path: '/api/v2/auth/dashboards/access',
             method: 'post',
@@ -27,6 +27,7 @@ class VizzlyApi extends Api_1.Api {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
             },
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
     fetchGlobalLibraries(params) {
@@ -41,14 +42,15 @@ class VizzlyApi extends Api_1.Api {
             body: {
                 globalLibraryAccessTokens: params.globalLibraryAccessTokens,
             },
+            abortSignal: params.abortSignal,
         };
     }
-    fetchGlobalLibraryAccessTokens() {
+    fetchGlobalLibraryAccessTokens(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest());
+            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest(params));
         });
     }
-    buildFetchGlobalLibraryAccessTokensRequest() {
+    buildFetchGlobalLibraryAccessTokensRequest(params) {
         return {
             path: '/api/v2/auth/global-library/access',
             method: 'post',
@@ -56,6 +58,7 @@ class VizzlyApi extends Api_1.Api {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
             },
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
     buildCreateDashboardRequest(params) {
@@ -69,15 +72,17 @@ class VizzlyApi extends Api_1.Api {
                 parentDashboardId: params.parentDashboardId,
                 permissions: params.permissions,
             },
+            abortSignal: params.abortSignal,
         };
     }
-    buildFetchDashboardsRequest(dashboardSessionAccessTokens) {
+    buildFetchDashboardsRequest(params) {
         return {
             path: '/api/v2/multi-get-dashboard',
             method: 'post',
             body: {
-                dashboardAccessTokens: dashboardSessionAccessTokens,
+                dashboardAccessTokens: params.dashboardSessionAccessTokens,
             },
+            abortSignal: params.abortSignal,
         };
     }
     createParentDashboard(params) {
@@ -93,6 +98,7 @@ class VizzlyApi extends Api_1.Api {
                 projectId: params.projectId,
                 definition: params.definition,
             },
+            abortSignal: params.abortSignal,
         };
     }
     createParentGlobalLibrary(params) {
@@ -108,6 +114,7 @@ class VizzlyApi extends Api_1.Api {
                 projectId: params.projectId,
                 library: params.library,
             },
+            abortSignal: params.abortSignal,
         };
     }
     createGlobalLibrary(params) {
@@ -128,20 +135,22 @@ class VizzlyApi extends Api_1.Api {
                 library: params.library,
                 permissions: params.permissions,
             },
+            abortSignal: params.abortSignal,
         };
     }
-    getProjects() {
+    getProjects(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildGetProjectsRequest());
+            return this.execute(this.buildGetProjectsRequest(params));
         });
     }
-    buildGetProjectsRequest() {
+    buildGetProjectsRequest(params) {
         return {
             path: `/api/v2/projects`,
             method: 'get',
             headers: {
                 auth: `Bearer ${this.auth.getAppSessionToken()}`,
             },
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
     createProjectApiKey(params) {
@@ -154,6 +163,7 @@ class VizzlyApi extends Api_1.Api {
             path: `/api/v3/project/${params.projectId}/api-key`,
             method: 'post',
             body: {},
+            abortSignal: params.abortSignal,
         };
     }
     createQueryEngineUser(params) {
@@ -169,41 +179,46 @@ class VizzlyApi extends Api_1.Api {
                 email: params.email,
                 password: params.password,
             },
+            abortSignal: params.abortSignal,
         };
     }
-    buildCreateSelfHostedDynamicQueryEngineProjectRequest() {
+    buildCreateSelfHostedDynamicQueryEngineProjectRequest(params) {
         return {
             path: `/api/v2/project/self-hosted-dynamic-query-engine`,
             method: 'post',
             body: {},
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
-    buildCreateSelfHostedInBrowserProjectRequest() {
+    buildCreateSelfHostedInBrowserProjectRequest(params) {
         return {
             path: `/api/v2/project/self-hosted-in-browser`,
             method: 'post',
             body: {},
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
-    buildCreateSelfHostedProjectRequest() {
+    buildCreateSelfHostedProjectRequest(params) {
         return {
             path: `/api/v2/project/self-hosted-query-engine`,
             method: 'post',
             body: {},
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
-    createManagedQueryEngineProject() {
+    createManagedQueryEngineProject(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildCreateManagedQueryEngineProjectRequest());
+            return yield this.execute(this.buildCreateManagedQueryEngineProjectRequest(params));
         });
     }
-    buildCreateManagedQueryEngineProjectRequest() {
+    buildCreateManagedQueryEngineProjectRequest(params) {
         return {
             path: `/api/v2/project/managed-query-engine`,
             method: 'post',
             body: {
                 parent_dashboard_definition: {},
             },
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
     createVizzlyConfigVersion(params) {
@@ -219,6 +234,7 @@ class VizzlyApi extends Api_1.Api {
                 projectId: params.projectId,
                 encryptedConfig: params.encryptedConfig,
             },
+            abortSignal: params.abortSignal,
         };
     }
     duplicateParentDashboard(params) {
@@ -233,6 +249,7 @@ class VizzlyApi extends Api_1.Api {
             body: {
                 dashboardId: params.dashboardId,
             },
+            abortSignal: params.abortSignal,
         };
     }
     getConnection(params) {
@@ -253,6 +270,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v2/project/${params.projectId}/connection`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getManagedQueryEngineKeyPair(params) {
@@ -264,6 +282,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v2/project/managed-query-engine/${params.managedProjectId}/key-pairs/${params.keyPairId}`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getProject(params) {
@@ -275,6 +294,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v3/project/${params.projectId}`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getProjectAccessToken(params) {
@@ -289,6 +309,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v2/auth/project/${params.projectId}/access_token?${filterString}`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getQueryEngineUser(params) {
@@ -300,6 +321,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v3/project/${params.projectId}/query-engine-user?email=${encodeURIComponent(params.email)}`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getTeamMembers(params) {
@@ -311,6 +333,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v3/project/${params.projectId}/organisation-team-members`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     getVizzlyConfig(params) {
@@ -328,6 +351,7 @@ class VizzlyApi extends Api_1.Api {
         return {
             path: `/api/v3/project/${params.projectId}/config`,
             method: 'get',
+            abortSignal: params.abortSignal,
         };
     }
     saveConnection(params) {
@@ -344,6 +368,7 @@ class VizzlyApi extends Api_1.Api {
                 encryptedConfig: params.encryptedConfig,
                 encryptedConnection: params.encryptedConnection,
             },
+            abortSignal: params.abortSignal,
         };
     }
     buildSaveEncryptedProjectEncryptionSecretRequest(params) {
@@ -355,6 +380,7 @@ class VizzlyApi extends Api_1.Api {
                 encryptedEncryptionSecret: params.encryptedProjectEncryptionSecret,
                 allowRotation: params.allowRotation,
             },
+            abortSignal: params.abortSignal,
         };
     }
     saveScheduledReport(params) {
@@ -371,6 +397,7 @@ class VizzlyApi extends Api_1.Api {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 scheduledReportId: params.scheduledReportId,
             },
+            abortSignal: params.abortSignal,
         };
     }
     updateDashboard(params) {
@@ -388,6 +415,7 @@ class VizzlyApi extends Api_1.Api {
                 meta: params.metadata || params.meta || {},
                 deleted: params.deleted,
             },
+            abortSignal: params.abortSignal,
         };
     }
     updateParentGlobalLibrary(params) {
@@ -404,6 +432,7 @@ class VizzlyApi extends Api_1.Api {
                 deleted: params.deleted,
                 name: params.name,
             },
+            abortSignal: params.abortSignal,
         };
     }
     updateGlobalLibrary(params) {
@@ -420,6 +449,7 @@ class VizzlyApi extends Api_1.Api {
                 deleted: params.deleted,
                 library: params.library,
             },
+            abortSignal: params.abortSignal,
         };
     }
     updateProjectApiKey(params) {
@@ -434,6 +464,7 @@ class VizzlyApi extends Api_1.Api {
             body: {
                 disabled: params.disabled,
             },
+            abortSignal: params.abortSignal,
         };
     }
     updateQueryEngineUser(params) {
@@ -449,6 +480,7 @@ class VizzlyApi extends Api_1.Api {
                 query_engine_user_id: params.queryEngineUserId,
                 password: params.password,
             },
+            abortSignal: params.abortSignal,
         };
     }
 }

package/dist/models/VizzlyQueryEngineApi.d.ts

@@ -1,82 +1,84 @@
 import { Api } from './Api';
 import { Authentication } from './Authentication';
-import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI } from '../types';
+import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams, UpdateGlobalLibraryParams, GlobalLibrary, CreateGlobalLibraryParams, GlobalLibraryPermission, GlobalLibraryPermissionFromAPI, RequestParams } from '../types';
 export declare class VizzlyQueryEngineApi extends Api {
     constructor(auth: Authentication, host: string, extraHeaders?: extraHeaders);
-    buildCreateDashboardRequest(params: CreateDashboardParams): Request<CreateDashboardParams & {
+    buildCreateDashboardRequest(params: RequestParams<CreateDashboardParams>): Request<CreateDashboardParams & {
         dashboardAccessToken: string;
     }>;
-    buildFetchDashboardAccessTokensRequest(): Request<{
+    buildFetchDashboardAccessTokensRequest(params?: RequestParams): Request<{
         projectAdminOverrideToken: string | undefined;
         dashboardAccessToken: string;
     }>;
-    fetchGlobalLibraryAccessTokens(): Promise<import("../types").Response<{
+    fetchGlobalLibraryAccessTokens(params?: RequestParams): Promise<import("../types").Response<{
         global_libraries: GlobalLibrary[];
         permissions: Array<GlobalLibraryPermissionFromAPI>;
     }>>;
-    buildFetchGlobalLibraryAccessTokensRequest(): Request<{
+    buildFetchGlobalLibraryAccessTokensRequest(params?: RequestParams): Request<{
         projectAdminOverrideToken: string | undefined;
         dashboardAccessToken: string;
     }>;
-    buildFetchDashboardsRequest(dashboardSessionAccessTokens: string[]): Request<{}>;
-    createConfigFromUpload(createConfigFromUploadParams: nVizzlyQueryEngine.CreateConfigFromUploadParams): Promise<import("../types").Response<unknown>>;
+    buildFetchDashboardsRequest(params: RequestParams<{
+        dashboardSessionAccessTokens: string[];
+    }>): Request<{}>;
+    createConfigFromUpload(createConfigFromUploadParams: RequestParams<nVizzlyQueryEngine.CreateConfigFromUploadParams>): Promise<import("../types").Response<unknown>>;
     private buildCreateConfigFromUploadRequest;
-    createResults(params: nVizzlyQueryEngine.CreateResultsParams): Promise<import("../types").Response<unknown>>;
+    createResults(params: RequestParams<nVizzlyQueryEngine.CreateResultsParams>): Promise<import("../types").Response<unknown>>;
     private buildCreateResultsRequest;
-    createSqlPreview(params: nVizzlyQueryEngine.CreateSqlPreviewParams): Promise<import("../types").Response<{
+    createSqlPreview(params: RequestParams<nVizzlyQueryEngine.CreateSqlPreviewParams>): Promise<import("../types").Response<{
         message: string;
     }>>;
-    buildCreateSqlPreviewRequest(params: nVizzlyQueryEngine.CreateSqlPreviewParams): Request<{}>;
-    createQueryEngineUser(params: nVizzlyQueryEngine.CreateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
-    buildCreateQueryEngineUserRequest(params: nVizzlyQueryEngine.CreateQueryEngineUserParams): Request<{}>;
-    fetchDataSets(): Promise<import("../types").Response<unknown>>;
-    buildFetchDataSetsRequest(): Request<{}>;
-    fetchSelfHostedQueryEngineConfig(): Promise<import("../types").Response<unknown>>;
-    buildFetchSelfHostedQueryEngineConfigRequest(): Request<{}>;
-    fetchProject(): Promise<import("../types").Response<unknown>>;
-    buildFetchProjectRequest(): Request<{}>;
-    getStarted(params: nVizzlyQueryEngine.GetStartedParams): Promise<import("../types").Response<{
+    buildCreateSqlPreviewRequest(params: RequestParams<nVizzlyQueryEngine.CreateSqlPreviewParams>): Request<{}>;
+    createQueryEngineUser(params: RequestParams<nVizzlyQueryEngine.CreateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    buildCreateQueryEngineUserRequest(params: RequestParams<nVizzlyQueryEngine.CreateQueryEngineUserParams>): Request<{}>;
+    fetchDataSets(params: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildFetchDataSetsRequest(params?: RequestParams): Request<{}>;
+    fetchSelfHostedQueryEngineConfig(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildFetchSelfHostedQueryEngineConfigRequest(params?: RequestParams): Request<{}>;
+    fetchProject(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildFetchProjectRequest(params?: RequestParams): Request<{}>;
+    getStarted(params: RequestParams<nVizzlyQueryEngine.GetStartedParams>): Promise<import("../types").Response<{
         reason?: string | undefined;
     }>>;
-    buildGetStartedRequest(params: nVizzlyQueryEngine.GetStartedParams): Request<{}>;
-    getTeamMembers(): Promise<import("../types").Response<unknown>>;
-    buildGetTeamMembersRequest(): Request<{}>;
-    isVizzly(): Promise<import("../types").Response<unknown>>;
-    buildIsVizzlyRequest(): Request<{}>;
-    saveConfig(params: nVizzlyQueryEngine.SaveConfigParams): Promise<import("../types").Response<unknown>>;
-    buildSaveConfigRequest(params: nVizzlyQueryEngine.SaveConfigParams): Request<{}>;
-    saveConnection(params: nVizzlyQueryEngine.SaveConnectionParams): Promise<import("../types").Response<unknown>>;
-    buildSaveConnectionRequest(params: nVizzlyQueryEngine.SaveConnectionParams): Request<{}>;
-    signInWithQueryEngineAccessToken(): Promise<import("../types").Response<unknown>>;
-    buildSignInWithQueryEngineAccessTokenRequest(): Request<{}>;
-    signInWithEmailAndPassword(params: nVizzlyQueryEngine.SignInWithEmailAndPasswordParams): Promise<import("../types").Response<unknown>>;
-    buildSignInWithEmailAndPasswordRequest(params: nVizzlyQueryEngine.SignInWithEmailAndPasswordParams): Request<{}>;
-    status(): Promise<import("../types").Response<unknown>>;
-    buildStatusRequest(): Request<{}>;
-    createGlobalLibrary(params: CreateGlobalLibraryParams): Promise<{
+    buildGetStartedRequest(params: RequestParams<nVizzlyQueryEngine.GetStartedParams>): Request<{}>;
+    getTeamMembers(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildGetTeamMembersRequest(params?: RequestParams): Request<{}>;
+    isVizzly(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildIsVizzlyRequest(params?: RequestParams): Request<{}>;
+    saveConfig(params: RequestParams<nVizzlyQueryEngine.SaveConfigParams>): Promise<import("../types").Response<unknown>>;
+    buildSaveConfigRequest(params: RequestParams<nVizzlyQueryEngine.SaveConfigParams>): Request<{}>;
+    saveConnection(params: RequestParams<nVizzlyQueryEngine.SaveConnectionParams>): Promise<import("../types").Response<unknown>>;
+    buildSaveConnectionRequest(params: RequestParams<nVizzlyQueryEngine.SaveConnectionParams>): Request<{}>;
+    signInWithQueryEngineAccessToken(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildSignInWithQueryEngineAccessTokenRequest(params?: RequestParams): Request<{}>;
+    signInWithEmailAndPassword(params: RequestParams<nVizzlyQueryEngine.SignInWithEmailAndPasswordParams>): Promise<import("../types").Response<unknown>>;
+    buildSignInWithEmailAndPasswordRequest(params: RequestParams<nVizzlyQueryEngine.SignInWithEmailAndPasswordParams>): Request<{}>;
+    status(params?: RequestParams): Promise<import("../types").Response<unknown>>;
+    buildStatusRequest(params?: RequestParams): Request<{}>;
+    createGlobalLibrary(params: RequestParams<CreateGlobalLibraryParams>): Promise<{
         global_library: GlobalLibrary;
         permissions: Array<GlobalLibraryPermission>;
     }>;
-    buildCreateGlobalLibraryRequest(params: CreateGlobalLibraryParams): Request<{}>;
-    fetchGlobalLibraries(params: {
+    buildCreateGlobalLibraryRequest(params: RequestParams<CreateGlobalLibraryParams>): Request<{}>;
+    fetchGlobalLibraries(params: RequestParams<{
         globalLibraryAccessTokens: string[];
-    }): Promise<import("../types").Response<{
+    }>): Promise<import("../types").Response<{
         found: GlobalLibrary[];
         not_found: string[];
     }>>;
-    buildFetchGlobalLibrariesRequest(params: {
+    buildFetchGlobalLibrariesRequest(params: RequestParams<{
         globalLibraryAccessTokens: string[];
-    }): Request<{
+    }>): Request<{
         globalLibraryAccessTokens: string[];
     }>;
-    updateGlobalLibrary(params: UpdateGlobalLibraryParams): Promise<import("../types").Response<{
+    updateGlobalLibrary(params: RequestParams<UpdateGlobalLibraryParams>): Promise<import("../types").Response<{
         global_library: GlobalLibrary;
     }>>;
-    buildUpdateGlobalLibraryRequest(params: UpdateGlobalLibraryParams): Request<{}>;
-    updateDashboard(params: UpdateDashboardParams): Promise<import("../types").Response<unknown>>;
-    buildUpdateDashboardRequest(params: UpdateDashboardParams): Request<{}>;
-    updateQueryEngineUser(params: nVizzlyQueryEngine.UpdateQueryEngineUserParams): Promise<import("../types").Response<unknown>>;
-    buildUpdateQueryEngineUserRequest(params: nVizzlyQueryEngine.UpdateQueryEngineUserParams): Request<{}>;
-    uploadDataToVizzlyCloud(params: nVizzlyQueryEngine.UploadDataToVizzlyCloudParams): Promise<import("../types").Response<unknown>>;
-    buildUploadDataToVizzlyCloudRequest(params: nVizzlyQueryEngine.UploadDataToVizzlyCloudParams): Request<{}>;
+    buildUpdateGlobalLibraryRequest(params: RequestParams<UpdateGlobalLibraryParams>): Request<{}>;
+    updateDashboard(params: RequestParams<UpdateDashboardParams>): Promise<import("../types").Response<unknown>>;
+    buildUpdateDashboardRequest(params: RequestParams<UpdateDashboardParams>): Request<{}>;
+    updateQueryEngineUser(params: RequestParams<nVizzlyQueryEngine.UpdateQueryEngineUserParams>): Promise<import("../types").Response<unknown>>;
+    buildUpdateQueryEngineUserRequest(params: RequestParams<nVizzlyQueryEngine.UpdateQueryEngineUserParams>): Request<{}>;
+    uploadDataToVizzlyCloud(params: RequestParams<nVizzlyQueryEngine.UploadDataToVizzlyCloudParams>): Promise<import("../types").Response<unknown>>;
+    buildUploadDataToVizzlyCloudRequest(params: RequestParams<nVizzlyQueryEngine.UploadDataToVizzlyCloudParams>): Request<{}>;
 }

package/dist/models/VizzlyQueryEngineApi.js

@@ -23,6 +23,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: '/api/v1/dashboard',
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 definition: params.definition,
@@ -32,37 +33,40 @@ class VizzlyQueryEngineApi extends Api_1.Api {
             },
         };
     }
-    buildFetchDashboardAccessTokensRequest() {
+    buildFetchDashboardAccessTokensRequest(params) {
         return {
             path: '/api/v1/dashboard/access',
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
             },
         };
     }
-    fetchGlobalLibraryAccessTokens() {
+    fetchGlobalLibraryAccessTokens(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest());
+            return yield this.execute(this.buildFetchGlobalLibraryAccessTokensRequest(params));
         });
     }
-    buildFetchGlobalLibraryAccessTokensRequest() {
+    buildFetchGlobalLibraryAccessTokensRequest(params) {
         return {
             path: '/api/v1/global-library/access',
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
             },
         };
     }
-    buildFetchDashboardsRequest(dashboardSessionAccessTokens) {
+    buildFetchDashboardsRequest(params) {
         return {
             path: '/api/v1/get-dashboards',
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
-                dashboardAccessTokens: dashboardSessionAccessTokens,
+                dashboardAccessTokens: params.dashboardSessionAccessTokens,
             },
         };
     }
@@ -75,6 +79,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/create-config-from-upload`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 queryEngineAccessToken: this.auth.getQueryEngineAccessToken(),
                 table: params.table,
@@ -91,6 +96,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/create-results`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 queries: params.queries,
                 virtualFields: {},
@@ -111,6 +117,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/create-sql-preview`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 sql: params.sql,
                 parameters: params.parameters,
@@ -127,51 +134,55 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/query-engine-user`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 email: params.email,
                 password: params.password,
             },
         };
     }
-    fetchDataSets() {
+    fetchDataSets(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const request = this.buildFetchDataSetsRequest();
+            const request = this.buildFetchDataSetsRequest(params);
             const result = yield this.execute(request);
             if (result.status === 200)
                 return result;
             throw new FailedToResolveDataSets_1.FailedToResolveDataSets(`Failed to resolve data sets from ${request.path}. Received status ${result.status}`);
         });
     }
-    buildFetchDataSetsRequest() {
+    buildFetchDataSetsRequest(params) {
         return {
             path: `/api/v1/resolve-data-sets`,
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {
                 integritySignature: this.auth.getDataAccessToken(),
             },
         };
     }
-    fetchSelfHostedQueryEngineConfig() {
+    fetchSelfHostedQueryEngineConfig(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildFetchSelfHostedQueryEngineConfigRequest());
+            return this.execute(this.buildFetchSelfHostedQueryEngineConfigRequest(params));
         });
     }
-    buildFetchSelfHostedQueryEngineConfigRequest() {
+    buildFetchSelfHostedQueryEngineConfigRequest(params) {
         return {
             path: `/api/v1/support`,
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {},
         };
     }
-    fetchProject() {
+    fetchProject(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildFetchProjectRequest());
+            return this.execute(this.buildFetchProjectRequest(params));
         });
     }
-    buildFetchProjectRequest() {
+    buildFetchProjectRequest(params) {
         return {
             path: `/api/v1/project`,
             method: 'get',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {},
         };
     }
@@ -190,32 +201,35 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v2/get-started`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 email: params.email,
                 password: params.password,
             },
         };
     }
-    getTeamMembers() {
+    getTeamMembers(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildGetTeamMembersRequest());
+            return this.execute(this.buildGetTeamMembersRequest(params));
         });
     }
-    buildGetTeamMembersRequest() {
+    buildGetTeamMembersRequest(params) {
         return {
             path: `/api/v1/team-members`,
             method: 'get',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
-    isVizzly() {
+    isVizzly(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildIsVizzlyRequest());
+            return this.execute(this.buildIsVizzlyRequest(params));
         });
     }
-    buildIsVizzlyRequest() {
+    buildIsVizzlyRequest(params) {
         return {
             path: `/api/is-vizzly`,
             method: 'get',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
         };
     }
     saveConfig(params) {
@@ -227,6 +241,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/save-config`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 config: params.config,
             },
@@ -241,21 +256,23 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/save-connection`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 connection: params.connection,
                 client: params.client,
             },
         };
     }
-    signInWithQueryEngineAccessToken() {
+    signInWithQueryEngineAccessToken(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildSignInWithQueryEngineAccessTokenRequest());
+            return this.execute(this.buildSignInWithQueryEngineAccessTokenRequest(params));
         });
     }
-    buildSignInWithQueryEngineAccessTokenRequest() {
+    buildSignInWithQueryEngineAccessTokenRequest(params) {
         return {
             path: `/api/v1/sign-in`,
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {},
         };
     }
@@ -268,21 +285,23 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/sign-in`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 email: params.email,
                 password: params.password,
             },
         };
     }
-    status() {
+    status(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.execute(this.buildStatusRequest());
+            return this.execute(this.buildStatusRequest(params));
         });
     }
-    buildStatusRequest() {
+    buildStatusRequest(params) {
         return {
             path: `/api/status`,
             method: 'post',
+            abortSignal: params === null || params === void 0 ? void 0 : params.abortSignal,
             body: {},
         };
     }
@@ -298,6 +317,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: '/api/v1/global-library',
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 dashboardAccessToken: this.auth.getDashboardAccessToken(),
                 parentGlobalLibraryId: params.parentGlobalLibraryId,
@@ -315,6 +335,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: '/api/v1/get-global-libraries',
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 globalLibraryAccessTokens: params.globalLibraryAccessTokens,
             },
@@ -329,6 +350,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: '/api/v1/global-library',
             method: 'put',
+            abortSignal: params.abortSignal,
             body: {
                 globalLibrarySessionToken: params.globalLibrarySessionToken,
                 deleted: params.deleted,
@@ -345,6 +367,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/dashboard`,
             method: 'put',
+            abortSignal: params.abortSignal,
             body: {
                 dashboardSessionToken: params.dashboardPermission.token,
                 definition: params.definition,
@@ -362,6 +385,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/query-engine-user`,
             method: 'put',
+            abortSignal: params.abortSignal,
             body: {
                 queryEngineUserId: params.queryEngineUserId,
                 password: params.password,
@@ -377,6 +401,7 @@ class VizzlyQueryEngineApi extends Api_1.Api {
         return {
             path: `/api/v1/ingest`,
             method: 'post',
+            abortSignal: params.abortSignal,
             body: {
                 queryEngineAccessToken: this.auth.getQueryEngineAccessToken(),
                 ingest: params.ingest,

package/dist/types.d.ts

@@ -61,6 +61,9 @@ export type APIs = {
 export type extraHeaders = () => {
     [key: string]: string;
 };
+export type RequestParams<T = {}> = T & {
+    abortSignal?: AbortSignal;
+};
 export type AuthParams = {
     projectAdminOverrideToken?: string;
     queryEngineAccessToken?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizzly/api-client",
-  "version": "0.0.16",
+  "version": "0.0.19",
   "private": false,
   "license": "NONE",
   "source": "src/index.ts",