@vizzly/api-client 0.0.1

package/dist/models/VizzlyAppApi.js

@@ -0,0 +1,348 @@
+"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.VizzlyAppApi = void 0;
+const Api_1 = require("./Api");
+class VizzlyAppApi extends Api_1.Api {
+    constructor(auth, host = 'https://app.vizzly.co') {
+        super(auth, host);
+    }
+    createCliAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateCliAuthTokenRequest());
+        });
+    }
+    buildCreateCliAuthTokenRequest() {
+        return {
+            path: '/api/create-cli-auth-token',
+            method: 'post',
+            body: {},
+        };
+    }
+    createInstantDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateInstantDashboardRequest(params));
+        });
+    }
+    buildCreateInstantDashboardRequest(params) {
+        return {
+            path: '/api/v2/instant-dashboard',
+            method: 'post',
+            body: {
+                parent_dashboard_definition: params.definition,
+            },
+        };
+    }
+    createProjectAdminOverrideAccessToken(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCreateProjectAdminOverrideAccessTokenRequest(params));
+        });
+    }
+    buildCreateProjectAdminOverrideAccessTokenRequest(params) {
+        return {
+            path: `/api/v2/project/${params.projectId}/admin-override`,
+            method: 'post',
+            body: {},
+        };
+    }
+    startEmailChange(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildStartEmailChangeRequest(params));
+        });
+    }
+    buildStartEmailChangeRequest(params) {
+        return {
+            path: '/api/self/start-email-change',
+            method: 'post',
+            body: {
+                email: params.email,
+            },
+        };
+    }
+    completeEmailChange(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCompleteEmailChangeRequest(params));
+        });
+    }
+    buildCompleteEmailChangeRequest(params) {
+        return {
+            path: '/api/self/complete-email-change',
+            method: 'post',
+            body: {
+                token: params.token,
+            },
+        };
+    }
+    getManagedQueryEngineAccessTokens(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetManagedQueryEngineAccessTokensRequest(params));
+        });
+    }
+    buildGetManagedQueryEngineAccessTokensRequest(params) {
+        return {
+            path: `/api/v2/managed-query-engine/${params.managedQueryEngineId}/identity`,
+            method: 'get',
+        };
+    }
+    getParentDashboardMeta(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetParentDashboardMetaRequest(params));
+        });
+    }
+    buildGetParentDashboardMetaRequest(params) {
+        return {
+            path: `/api/v2/parent-dashboard/${params.dashboardId}/stats`,
+            method: 'get',
+        };
+    }
+    updateParentDashboard(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateParentDashboardRequest(params));
+        });
+    }
+    buildUpdateParentDashboardRequest(params) {
+        return {
+            path: `/api/v2/parent-dashboard/${params.dashboardId}/stats`,
+            method: 'put',
+            body: {
+                name: params.name,
+                definition: params.definition,
+                meta: params.meta,
+                deleted: params.deleted,
+                webhookId: params.webhookId,
+            },
+        };
+    }
+    getProjectMeta(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetProjectMetaRequest(params));
+        });
+    }
+    buildGetProjectMetaRequest(params) {
+        return {
+            path: `/api/v2/project/${params.projectId}/meta`,
+            method: 'get',
+        };
+    }
+    getSelf() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetSelfRequest());
+        });
+    }
+    buildGetSelfRequest() {
+        return {
+            path: `/api/self`,
+            method: 'get',
+        };
+    }
+    getTeam() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetTeamRequest());
+        });
+    }
+    buildGetTeamRequest() {
+        return {
+            path: `/api/team`,
+            method: 'get',
+        };
+    }
+    getWebhooks() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildGetWebhooksRequest());
+        });
+    }
+    buildGetWebhooksRequest() {
+        return {
+            path: '/api/organisation/webhooks',
+            method: 'get',
+        };
+    }
+    inviteTeamMember(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildInviteTeamMemberRequest(params));
+        });
+    }
+    buildInviteTeamMemberRequest(params) {
+        return {
+            path: '/api/invite',
+            method: 'post',
+            body: {
+                email: params.email,
+                first_name: params.firstName,
+                last_name: params.lastName,
+                department: params.department,
+            },
+        };
+    }
+    inAppAcceptTeamMemberInvite(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildInAppAcceptTeamMemberInviteRequest(params));
+        });
+    }
+    buildInAppAcceptTeamMemberInviteRequest(params) {
+        return {
+            path: '/api/invite/in-app-accept',
+            method: 'post',
+            body: {
+                team_member_id: params.teamMemberId,
+            },
+        };
+    }
+    acceptTeamMemberInvite(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildAcceptTeamMemberInviteRequest(params));
+        });
+    }
+    buildAcceptTeamMemberInviteRequest(params) {
+        return {
+            path: '/api/invite/accept',
+            method: 'post',
+            body: {
+                token: params.inviteToken,
+            },
+        };
+    }
+    resendTeamMemberInvite(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildResendTeamMemberInviteRequest(params));
+        });
+    }
+    buildResendTeamMemberInviteRequest(params) {
+        return {
+            path: '/api/invite/resend',
+            method: 'post',
+            body: {
+                team_member_id: params.teamMemberId,
+            },
+        };
+    }
+    removeTeamMember(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildRemoveTeamMemberRequest(params));
+        });
+    }
+    buildRemoveTeamMemberRequest(params) {
+        return {
+            path: '/api/invite/remove',
+            method: 'post',
+            body: {
+                team_member_id: params.teamMemberId,
+            },
+        };
+    }
+    startSignIn(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildStartSignInRequest(params));
+        });
+    }
+    buildStartSignInRequest(params) {
+        return {
+            path: '/api/start-sign-in',
+            method: 'post',
+            body: {
+                email: params.email,
+            },
+        };
+    }
+    completeSignIn(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildCompleteSignInRequest(params));
+        });
+    }
+    buildCompleteSignInRequest(params) {
+        return {
+            path: '/api/complete-sign-in',
+            method: 'post',
+            body: {
+                token: params.token,
+            },
+        };
+    }
+    signUp(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSignUpRequest(params));
+        });
+    }
+    buildSignUpRequest(params) {
+        return {
+            path: '/api/complete-sign-in',
+            method: 'post',
+            body: {
+                email: params.email,
+                organisation_title: params.organisationTitle,
+                first_name: params.firstName,
+                last_name: params.lastName,
+                department: params.department,
+            },
+        };
+    }
+    switchOrganisation(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildSwitchOrganisationRequest(params));
+        });
+    }
+    buildSwitchOrganisationRequest(params) {
+        return {
+            path: '/api/team/switch',
+            method: 'post',
+            body: {
+                organisation_id: params.organisationId,
+            },
+        };
+    }
+    toggleKeyPairDisabled(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildToggleKeyPairDisabledRequest(params));
+        });
+    }
+    buildToggleKeyPairDisabledRequest(params) {
+        return {
+            path: '/api/organisation/key-pairs/toggle-disabled',
+            method: 'post',
+            body: {
+                key_pair_id: params.keyPairId,
+                disabled: params.disabled,
+            },
+        };
+    }
+    updateProject(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUpdateProjectRequest(params));
+        });
+    }
+    buildUpdateProjectRequest(params) {
+        return {
+            path: '/api/v2/project',
+            method: 'put',
+            body: {
+                project_id: params.projectId,
+                deleted: params.deleted,
+                name: params.name,
+            },
+        };
+    }
+    uploadPublicKey(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.execute(this.buildUploadPublicKeyRequest(params));
+        });
+    }
+    buildUploadPublicKeyRequest(params) {
+        return {
+            path: '/api/v2/project/key-pair',
+            method: 'post',
+            body: {
+                public_key: params.publicKey,
+                project_id: params.projectId,
+            },
+        };
+    }
+}
+exports.VizzlyAppApi = VizzlyAppApi;

package/dist/models/VizzlyQueryEngineApi.d.ts

@@ -0,0 +1,50 @@
+import { Api } from './Api';
+import { Authentication } from './Authentication';
+import { nVizzlyQueryEngine, Request, extraHeaders, CreateDashboardParams, UpdateDashboardParams } from '../types';
+export declare class VizzlyQueryEngineApi extends Api {
+    constructor(auth: Authentication, host: string, extraHeaders?: extraHeaders);
+    buildCreateDashboardRequest(params: CreateDashboardParams): Request<CreateDashboardParams & {
+        dashboardAccessToken: string;
+    }>;
+    buildFetchDashboardsRequest(dashboardSessionAccessTokens: string[]): Request<{}>;
+    createConfigFromUpload(createConfigFromUploadParams: nVizzlyQueryEngine.CreateConfigFromUploadParams): Promise<import("../types").Response<unknown>>;
+    private buildCreateConfigFromUploadRequest;
+    createResults(params: nVizzlyQueryEngine.CreateResultsParams): Promise<import("../types").Response<unknown>>;
+    private buildCreateResultsRequest;
+    createSqlPreview(params: 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<{
+        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<{}>;
+    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<{}>;
+}