@vizzly/api-client 0.0.1

package/dist/models/VizzlyApi.js

@@ -0,0 +1,423 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VizzlyApi = void 0;
+const Api_1 = require("./Api");
+class VizzlyApi extends Api_1.Api {
+    constructor(auth, host = 'https://api.vizzly.co') {
+        super(auth, host);
+    }
+    buildFetchDashboardAccessTokensRequest() {
+        return {
+            path: '/api/v2/auth/dashboards/access',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
+            },
+        };
+    }
+    buildFetchGlobalLibrariesRequest(params) {
+        return {
+            path: '/api/v2/multi-get-global-library',
+            method: 'post',
+            body: {
+                globalLibraryAccessTokens: params.globalLibraryAccessTokens,
+            },
+        };
+    }
+    buildFetchGlobalLibraryAccessTokensRequest() {
+        return {
+            path: '/api/v2/auth/global-library/access',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                projectAdminOverrideToken: this.auth.getProjectAdminOverrideToken(),
+            },
+        };
+    }
+    buildCreateDashboardRequest(params) {
+        return {
+            path: '/api/v2/dashboard',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                definition: params.definition,
+                meta: params.metadata || {},
+                parentDashboardId: params.parentDashboardId,
+                permissions: params.permissions,
+            },
+        };
+    }
+    buildFetchDashboardsRequest(dashboardSessionAccessTokens) {
+        return {
+            path: '/api/v2/multi-get-dashboard',
+            method: 'post',
+            body: {
+                dashboardAccessTokens: dashboardSessionAccessTokens,
+            },
+        };
+    }
+    createParentDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateParentDashboardRequest(params));
+        });
+    }
+    buildCreateParentDashboardRequest(params) {
+        return {
+            path: '/api/v2/parent-dashboard',
+            method: 'post',
+            body: {
+                projectId: params.projectId,
+                definition: params.definition,
+            },
+        };
+    }
+    createParentGlobalLibrary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateParentGlobalLibraryRequest(params));
+        });
+    }
+    buildCreateParentGlobalLibraryRequest(params) {
+        return {
+            path: '/api/v2/parent-global-library',
+            method: 'post',
+            body: {
+                projectId: params.projectId,
+                library: params.library,
+            },
+        };
+    }
+    createGlobalLibrary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateGlobalLibraryRequest(params));
+        });
+    }
+    buildCreateGlobalLibraryRequest(params) {
+        return {
+            path: '/api/v2/global-library',
+            method: 'post',
+            body: {
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                parentGlobalLibraryId: params.parentGlobalLibraryId,
+                library: params.library,
+                permissions: params.permissions,
+            },
+        };
+    }
+    getProjects() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.execute(this.buildGetProjectsRequest());
+        });
+    }
+    buildGetProjectsRequest() {
+        return {
+            path: `/api/v2/projects`,
+            method: 'get',
+            headers: {
+                auth: `Bearer ${this.auth.getAppSessionToken()}`,
+            },
+        };
+    }
+    createProjectApiKey(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateProjectApiKeyRequest(params));
+        });
+    }
+    buildCreateProjectApiKeyRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/api-key`,
+            method: 'post',
+            body: {},
+        };
+    }
+    createQueryEngineUser(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateQueryEngineUserRequest(params));
+        });
+    }
+    buildCreateQueryEngineUserRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/query-engine-user`,
+            method: 'post',
+            body: {
+                email: params.email,
+                password: params.password,
+            },
+        };
+    }
+    buildCreateSelfHostedDynamicQueryEngineProjectRequest() {
+        return {
+            path: `/api/v2/project/self-hosted-dynamic-query-engine`,
+            method: 'post',
+            body: {},
+        };
+    }
+    buildCreateSelfHostedInBrowserProjectRequest() {
+        return {
+            path: `/api/v2/project/self-hosted-in-browser`,
+            method: 'post',
+            body: {},
+        };
+    }
+    buildCreateSelfHostedProjectRequest() {
+        return {
+            path: `/api/v2/project/self-hosted-query-engine`,
+            method: 'post',
+            body: {},
+        };
+    }
+    createManagedQueryEngineProject() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateManagedQueryEngineProjectRequest());
+        });
+    }
+    buildCreateManagedQueryEngineProjectRequest() {
+        return {
+            path: `/api/v2/project/managed-query-engine`,
+            method: 'post',
+            body: {
+                parent_dashboard_definition: {},
+            },
+        };
+    }
+    createVizzlyConfigVersion(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateVizzlyConfigVersionRequest(params));
+        });
+    }
+    buildCreateVizzlyConfigVersionRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/config`,
+            method: 'post',
+            body: {
+                projectId: params.projectId,
+                encryptedConfig: params.encryptedConfig,
+            },
+        };
+    }
+    duplicateParentDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildDuplicateParentDashboardRequest(params));
+        });
+    }
+    buildDuplicateParentDashboardRequest(params) {
+        return {
+            path: `/api/v2/duplicate-parent-dashboard`,
+            method: 'post',
+            body: {
+                dashboardId: params.dashboardId,
+            },
+        };
+    }
+    getConnection(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetConnectionRequest(params));
+        });
+    }
+    buildGetConnectionRequest(params) {
+        return {
+            path: `/api/v2/project/${params.projectId}/connection`,
+            method: 'get',
+        };
+    }
+    getManagedQueryEngineKeyPair(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetManagedQueryEngineKeyPairRequest(params));
+        });
+    }
+    buildGetManagedQueryEngineKeyPairRequest(params) {
+        return {
+            path: `/api/v2/project/managed-query-engine/${params.managedProjectId}/key-pairs/${params.keyPairId}`,
+            method: 'get',
+        };
+    }
+    getProject(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetProjectRequest(params));
+        });
+    }
+    buildGetProjectRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}`,
+            method: 'get',
+        };
+    }
+    getProjectAccessToken(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetProjectAccessTokenRequest(params));
+        });
+    }
+    buildGetProjectAccessTokenRequest(params) {
+        let filterString = '';
+        if (params.resourceFilters)
+            filterString = `filter=${params.resourceFilters.join(',')}`;
+        return {
+            path: `/api/v2/auth/project/${params.projectId}/access_token?${filterString}`,
+            method: 'get',
+        };
+    }
+    getQueryEngineUser(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetQueryEngineUserRequest(params));
+        });
+    }
+    buildGetQueryEngineUserRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/query-engine-user?email=${encodeURIComponent(params.email)}`,
+            method: 'get',
+        };
+    }
+    getTeamMembers(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetTeamMembersRequest(params));
+        });
+    }
+    buildGetTeamMembersRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/organisation-team-members`,
+            method: 'get',
+        };
+    }
+    getVizzlyConfig(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetVizzlyConfigRequest(params));
+        });
+    }
+    buildGetVizzlyConfigRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/config`,
+            method: 'get',
+        };
+    }
+    saveConnection(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSaveConnectionRequest(params));
+        });
+    }
+    buildSaveConnectionRequest(params) {
+        return {
+            path: `/api/v3/project/connection`,
+            method: 'post',
+            body: {
+                projectId: params.projectId,
+                encryptedConfig: params.encryptedConfig,
+                encryptedConnection: params.encryptedConnection,
+            },
+        };
+    }
+    buildSaveEncryptedProjectEncryptionSecretRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/encrypted-encryption-secret`,
+            method: 'post',
+            body: {
+                projectId: params.projectId,
+                encryptedEncryptionSecret: params.encryptedProjectEncryptionSecret,
+                allowRotation: params.allowRotation,
+            },
+        };
+    }
+    saveScheduledReport(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSaveScheduledReportRequest(params));
+        });
+    }
+    buildSaveScheduledReportRequest(params) {
+        return {
+            path: '/api/scheduled-report',
+            method: 'post',
+            body: {
+                cronSchedule: params.cronSchedule,
+                dashboardAccessToken: this.auth.getDashboardAccessToken(),
+                scheduledReportId: params.scheduledReportId,
+            },
+        };
+    }
+    updateDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateDashboardRequest(params));
+        });
+    }
+    buildUpdateDashboardRequest(params) {
+        return {
+            path: '/api/v2/dashboard',
+            method: 'put',
+            body: {
+                dashboardSessionToken: params.dashboardSessionToken,
+                definition: params.definition,
+                meta: params.metadata || params.meta || {},
+                deleted: params.deleted,
+            },
+        };
+    }
+    updateParentGlobalLibrary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateParentGlobalLibraryRequest(params));
+        });
+    }
+    buildUpdateParentGlobalLibraryRequest(params) {
+        return {
+            path: '/api/v2/parent-global-library',
+            method: 'put',
+            body: {
+                globalLibraryId: params.globalLibraryId,
+                deleted: params.deleted,
+                name: params.name,
+            },
+        };
+    }
+    updateGlobalLibrary(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateGlobalLibraryRequest(params));
+        });
+    }
+    buildUpdateGlobalLibraryRequest(params) {
+        return {
+            path: '/api/v2/global-library',
+            method: 'put',
+            body: {
+                globalLibrarySessionToken: params.globalLibrarySessionToken,
+                deleted: params.deleted,
+                library: params.library,
+            },
+        };
+    }
+    updateProjectApiKey(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateProjectApiKeyRequest(params));
+        });
+    }
+    buildUpdateProjectApiKeyRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/api-key/${params.projectApiKeyId}`,
+            method: 'put',
+            body: {
+                disabled: params.disabled,
+            },
+        };
+    }
+    updateQueryEngineUser(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateQueryEngineUserRequest(params));
+        });
+    }
+    buildUpdateQueryEngineUserRequest(params) {
+        return {
+            path: `/api/v3/project/${params.projectId}/query-engine-user`,
+            method: 'put',
+            body: {
+                query_engine_user_id: params.queryEngineUserId,
+                password: params.password,
+            },
+        };
+    }
+}
+exports.VizzlyApi = VizzlyApi;

package/dist/models/VizzlyAppApi.d.ts

@@ -0,0 +1,54 @@
+import { GetSelfResponse, Request, nVizzlyAppApi } from '../types';
+import { Api } from './Api';
+import { Authentication } from './Authentication';
+export declare class VizzlyAppApi extends Api {
+    constructor(auth: Authentication, host?: string);
+    createCliAuthToken(): Promise<import("../types").Response<unknown>>;
+    buildCreateCliAuthTokenRequest(): Request<{}>;
+    createInstantDashboard(params: nVizzlyAppApi.CreateInstantDashboardParams): Promise<import("../types").Response<unknown>>;
+    buildCreateInstantDashboardRequest(params: nVizzlyAppApi.CreateInstantDashboardParams): Request<{}>;
+    createProjectAdminOverrideAccessToken(params: nVizzlyAppApi.CreateProjectAdminOverrideAccessTokenParams): Promise<import("../types").Response<unknown>>;
+    buildCreateProjectAdminOverrideAccessTokenRequest(params: nVizzlyAppApi.CreateProjectAdminOverrideAccessTokenParams): Request<{}>;
+    startEmailChange(params: nVizzlyAppApi.StartEmailChangeParams): Promise<import("../types").Response<unknown>>;
+    buildStartEmailChangeRequest(params: nVizzlyAppApi.StartEmailChangeParams): Request<{}>;
+    completeEmailChange(params: nVizzlyAppApi.CompleteEmailChangeParams): Promise<import("../types").Response<unknown>>;
+    buildCompleteEmailChangeRequest(params: nVizzlyAppApi.CompleteEmailChangeParams): Request<{}>;
+    getManagedQueryEngineAccessTokens(params: nVizzlyAppApi.GetManagedQueryEngineAccessTokensParams): Promise<import("../types").Response<unknown>>;
+    buildGetManagedQueryEngineAccessTokensRequest(params: nVizzlyAppApi.GetManagedQueryEngineAccessTokensParams): Request<{}>;
+    getParentDashboardMeta(params: nVizzlyAppApi.GetParentDashboardMetaParams): Promise<import("../types").Response<unknown>>;
+    buildGetParentDashboardMetaRequest(params: nVizzlyAppApi.GetParentDashboardMetaParams): Request<{}>;
+    updateParentDashboard(params: nVizzlyAppApi.UpdateParentDashboardParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateParentDashboardRequest(params: nVizzlyAppApi.UpdateParentDashboardParams): Request<{}>;
+    getProjectMeta(params: nVizzlyAppApi.GetProjectMetaParams): Promise<import("../types").Response<unknown>>;
+    buildGetProjectMetaRequest(params: nVizzlyAppApi.GetProjectMetaParams): Request<{}>;
+    getSelf(): Promise<import("../types").Response<GetSelfResponse>>;
+    buildGetSelfRequest(): Request<{}>;
+    getTeam(): Promise<import("../types").Response<unknown>>;
+    buildGetTeamRequest(): Request<{}>;
+    getWebhooks(): Promise<import("../types").Response<unknown>>;
+    buildGetWebhooksRequest(): Request<{}>;
+    inviteTeamMember(params: nVizzlyAppApi.InviteTeamMemberParams): Promise<import("../types").Response<unknown>>;
+    buildInviteTeamMemberRequest(params: nVizzlyAppApi.InviteTeamMemberParams): Request<{}>;
+    inAppAcceptTeamMemberInvite(params: nVizzlyAppApi.InAppAcceptTeamMemberInviteParams): Promise<import("../types").Response<unknown>>;
+    buildInAppAcceptTeamMemberInviteRequest(params: nVizzlyAppApi.InAppAcceptTeamMemberInviteParams): Request<{}>;
+    acceptTeamMemberInvite(params: nVizzlyAppApi.AcceptTeamMemberInviteParams): Promise<import("../types").Response<unknown>>;
+    buildAcceptTeamMemberInviteRequest(params: nVizzlyAppApi.AcceptTeamMemberInviteParams): Request<{}>;
+    resendTeamMemberInvite(params: nVizzlyAppApi.ResendTeamMemberInviteParams): Promise<import("../types").Response<unknown>>;
+    buildResendTeamMemberInviteRequest(params: nVizzlyAppApi.ResendTeamMemberInviteParams): Request<{}>;
+    removeTeamMember(params: nVizzlyAppApi.RemoveTeamMemberParams): Promise<import("../types").Response<unknown>>;
+    buildRemoveTeamMemberRequest(params: nVizzlyAppApi.RemoveTeamMemberParams): Request<{}>;
+    startSignIn(params: nVizzlyAppApi.StartSignInParams): Promise<import("../types").Response<unknown>>;
+    buildStartSignInRequest(params: nVizzlyAppApi.StartSignInParams): Request<{}>;
+    completeSignIn(params: nVizzlyAppApi.CompleteSignInParams): Promise<import("../types").Response<unknown>>;
+    buildCompleteSignInRequest(params: nVizzlyAppApi.CompleteSignInParams): Request<{}>;
+    signUp(params: nVizzlyAppApi.SignUpParams): Promise<import("../types").Response<unknown>>;
+    buildSignUpRequest(params: nVizzlyAppApi.SignUpParams): Request<{}>;
+    switchOrganisation(params: nVizzlyAppApi.SwitchOrganisationParams): Promise<import("../types").Response<unknown>>;
+    buildSwitchOrganisationRequest(params: nVizzlyAppApi.SwitchOrganisationParams): Request<{}>;
+    toggleKeyPairDisabled(params: nVizzlyAppApi.ToggleKeyPairDisabledParams): Promise<import("../types").Response<unknown>>;
+    buildToggleKeyPairDisabledRequest(params: nVizzlyAppApi.ToggleKeyPairDisabledParams): Request<{}>;
+    updateProject(params: nVizzlyAppApi.UpdateProjectParams): Promise<import("../types").Response<unknown>>;
+    buildUpdateProjectRequest(params: nVizzlyAppApi.UpdateProjectParams): Request<{}>;
+    uploadPublicKey(params: nVizzlyAppApi.UploadPublicKeyParams): Promise<import("../types").Response<unknown>>;
+    buildUploadPublicKeyRequest(params: nVizzlyAppApi.UploadPublicKeyParams): Request<{}>;
+}