@hubspot/local-dev-lib 0.0.5 → 0.0.6

package/api/customObjects.d.ts

@@ -0,0 +1,7 @@
+import { FetchSchemasResponse, Schema } from '../types/Schemas';
+export declare function batchCreateObjects(accountId: number, objectTypeId: string, objects: JSON): Promise<void>;
+export declare function createObjectSchema(accountId: number, schema: JSON): Promise<Schema>;
+export declare function updateObjectSchema(accountId: number, schemaObjectType: string, schema: Schema): Promise<Schema>;
+export declare function fetchObjectSchema(accountId: number, schemaObjectType: string): Promise<Schema>;
+export declare function fetchObjectSchemas(accountId: number): Promise<FetchSchemasResponse>;
+export declare function deleteObjectSchema(accountId: number, schemaObjectType: string): Promise<void>;

package/api/customObjects.js

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteObjectSchema = exports.fetchObjectSchemas = exports.fetchObjectSchema = exports.updateObjectSchema = exports.createObjectSchema = exports.batchCreateObjects = void 0;
+const http_1 = __importDefault(require("../http"));
+const CUSTOM_OBJECTS_API_PATH = 'crm/v3/objects';
+const SCHEMA_API_PATH = 'crm-object-schemas/v3/schemas';
+async function batchCreateObjects(accountId, objectTypeId, objects) {
+    http_1.default.post(accountId, {
+        url: `${CUSTOM_OBJECTS_API_PATH}/${objectTypeId}/batch/create`,
+        body: objects,
+    });
+}
+exports.batchCreateObjects = batchCreateObjects;
+async function createObjectSchema(accountId, schema) {
+    return http_1.default.post(accountId, {
+        url: SCHEMA_API_PATH,
+        body: schema,
+    });
+}
+exports.createObjectSchema = createObjectSchema;
+async function updateObjectSchema(accountId, schemaObjectType, schema) {
+    return http_1.default.patch(accountId, {
+        url: `${SCHEMA_API_PATH}/${schemaObjectType}`,
+        body: schema,
+    });
+}
+exports.updateObjectSchema = updateObjectSchema;
+async function fetchObjectSchema(accountId, schemaObjectType) {
+    return http_1.default.get(accountId, {
+        url: `${SCHEMA_API_PATH}/${schemaObjectType}`,
+    });
+}
+exports.fetchObjectSchema = fetchObjectSchema;
+async function fetchObjectSchemas(accountId) {
+    return http_1.default.get(accountId, {
+        url: SCHEMA_API_PATH,
+    });
+}
+exports.fetchObjectSchemas = fetchObjectSchemas;
+async function deleteObjectSchema(accountId, schemaObjectType) {
+    return http_1.default.delete(accountId, {
+        url: `${SCHEMA_API_PATH}/${schemaObjectType}`,
+    });
+}
+exports.deleteObjectSchema = deleteObjectSchema;

package/api/designManager.d.ts

@@ -0,0 +1,13 @@
+type FetchThemesResponse = {
+    objects: Array<{
+        theme: {
+            path: string;
+        };
+    }>;
+};
+export declare function fetchThemes(accountId: number, query?: {}): Promise<FetchThemesResponse>;
+type FetchBuiltinMappingResponse = {
+    [key: string]: string;
+};
+export declare function fetchBuiltinMapping(accountId: number): Promise<FetchBuiltinMappingResponse>;
+export {};

package/api/designManager.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchBuiltinMapping = exports.fetchThemes = void 0;
+const http_1 = __importDefault(require("../http"));
+const DESIGN_MANAGER_API_PATH = 'designmanager/v1';
+async function fetchThemes(accountId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${DESIGN_MANAGER_API_PATH}/themes/combined`,
+        query,
+    });
+}
+exports.fetchThemes = fetchThemes;
+async function fetchBuiltinMapping(accountId) {
+    return http_1.default.get(accountId, {
+        url: `${DESIGN_MANAGER_API_PATH}/widgets/builtin-mapping`,
+    });
+}
+exports.fetchBuiltinMapping = fetchBuiltinMapping;

package/api/fileManager.d.ts

@@ -0,0 +1,5 @@
+import { FetchStatResponse, FetchFilesOrFolderResponse, UploadResponse } from '../types/FileManager';
+export declare function uploadFile(accountId: number, src: string, dest: string): Promise<UploadResponse>;
+export declare function fetchStat(accountId: number, src: string): Promise<FetchStatResponse>;
+export declare function fetchFiles(accountId: number, folderId: number, offset: number, archived?: boolean): Promise<FetchFilesOrFolderResponse>;
+export declare function fetchFolders(accountId: number, folderId: number): Promise<FetchFilesOrFolderResponse>;

package/api/fileManager.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchFolders = exports.fetchFiles = exports.fetchStat = exports.uploadFile = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const http_1 = __importDefault(require("../http"));
+const FILE_MANAGER_V2_API_PATH = 'filemanager/api/v2';
+const FILE_MANAGER_V3_API_PATH = 'filemanager/api/v3';
+async function uploadFile(accountId, src, dest) {
+    const directory = path_1.default.dirname(dest);
+    const filename = path_1.default.basename(dest);
+    const formData = {
+        file: fs_1.default.createReadStream(src),
+        fileName: filename,
+        options: JSON.stringify({
+            access: 'PUBLIC_INDEXABLE',
+            overwrite: true,
+        }),
+    };
+    if (directory && directory !== '.') {
+        formData.folderPath = directory;
+    }
+    else {
+        formData.folderPath = '/';
+    }
+    return http_1.default.post(accountId, {
+        url: `${FILE_MANAGER_V3_API_PATH}/files/upload`,
+        formData,
+    });
+}
+exports.uploadFile = uploadFile;
+async function fetchStat(accountId, src) {
+    return http_1.default.get(accountId, {
+        url: `${FILE_MANAGER_V2_API_PATH}/files/stat/${src}`,
+    });
+}
+exports.fetchStat = fetchStat;
+async function fetchFiles(accountId, folderId, offset, archived) {
+    return http_1.default.get(accountId, {
+        url: `${FILE_MANAGER_V2_API_PATH}/files/`,
+        query: {
+            hidden: 0,
+            offset: offset,
+            folder_id: folderId,
+            ...(!archived && { archived: 0 }),
+        },
+    });
+}
+exports.fetchFiles = fetchFiles;
+async function fetchFolders(accountId, folderId) {
+    return http_1.default.get(accountId, {
+        url: `${FILE_MANAGER_V2_API_PATH}/folders/`,
+        query: {
+            hidden: 0,
+            parent_folder_id: folderId,
+        },
+    });
+}
+exports.fetchFolders = fetchFolders;

package/api/fileMapper.d.ts

@@ -0,0 +1,10 @@
+import { FileMapperNode, FileMapperOptions, FileTree } from '../types/Files';
+export declare const FILE_MAPPER_API_PATH = "content/filemapper/v1";
+export declare function upload(accountId: number, src: string, dest: string, options?: FileMapperOptions): Promise<void>;
+export declare function fetchModule(accountId: number, moduleId: number, options?: FileMapperOptions): Promise<FileTree>;
+export declare function fetchFileStream(accountId: number, filePath: string, destination: string, options?: FileMapperOptions): Promise<FileMapperNode>;
+export declare function download(accountId: number, filepath: string, options?: FileMapperOptions): Promise<FileMapperNode>;
+export declare function downloadDefault(accountId: number, filepath: string, options?: FileMapperOptions): Promise<FileMapperNode>;
+export declare function deleteFile(accountId: number, filePath: string, options?: FileMapperOptions): Promise<void>;
+export declare function moveFile(accountId: number, srcPath: string, destPath: string): Promise<void>;
+export declare function getDirectoryContentsByPath(accountId: number, path: string): Promise<void>;

package/api/fileMapper.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirectoryContentsByPath = exports.moveFile = exports.deleteFile = exports.downloadDefault = exports.download = exports.fetchFileStream = exports.fetchModule = exports.upload = exports.FILE_MAPPER_API_PATH = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const content_disposition_1 = __importDefault(require("content-disposition"));
+const http_1 = __importDefault(require("../http"));
+const path_2 = require("../lib/path");
+exports.FILE_MAPPER_API_PATH = 'content/filemapper/v1';
+function createFileMapperNodeFromStreamResponse(filePath, response) {
+    if (filePath[0] !== '/') {
+        filePath = `/${filePath}`;
+    }
+    if (filePath[filePath.length - 1] === '/') {
+        filePath = filePath.slice(0, filePath.length - 1);
+    }
+    const node = {
+        source: null,
+        path: filePath,
+        name: path_1.default.basename(filePath),
+        folder: false,
+        children: [],
+        createdAt: 0,
+        updatedAt: 0,
+    };
+    if (!(response.headers && response.headers['content-disposition'])) {
+        return node;
+    }
+    const { parameters } = content_disposition_1.default.parse(response.headers['content-disposition']);
+    return {
+        ...node,
+        name: parameters.filename,
+        createdAt: parseInt(parameters['creation-date'], 10) || 0,
+        updatedAt: parseInt(parameters['modification-date'], 10) || 0,
+    };
+}
+async function upload(accountId, src, dest, options = {}) {
+    return http_1.default.post(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/upload/${encodeURIComponent(dest)}`,
+        formData: {
+            file: fs_1.default.createReadStream(path_1.default.resolve((0, path_2.getCwd)(), src)),
+        },
+        ...options,
+    });
+}
+exports.upload = upload;
+// Fetch a module by moduleId
+async function fetchModule(accountId, moduleId, options = {}) {
+    return http_1.default.get(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/modules/${moduleId}`,
+        ...options,
+    });
+}
+exports.fetchModule = fetchModule;
+//Fetch a file by file path.
+async function fetchFileStream(accountId, filePath, destination, options = {}) {
+    const response = await http_1.default.getOctetStream(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/stream/${encodeURIComponent(filePath)}`,
+        ...options,
+    }, destination);
+    return createFileMapperNodeFromStreamResponse(filePath, response);
+}
+exports.fetchFileStream = fetchFileStream;
+// Fetch a folder or file node by path.
+async function download(accountId, filepath, options = {}) {
+    return http_1.default.get(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/download/${encodeURIComponent(filepath)}`,
+        ...options,
+    });
+}
+exports.download = download;
+// Fetch a folder or file node by path.
+async function downloadDefault(accountId, filepath, options = {}) {
+    return http_1.default.get(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/download-default/${filepath}`,
+        ...options,
+    });
+}
+exports.downloadDefault = downloadDefault;
+// Delete a file or folder by path
+async function deleteFile(accountId, filePath, options = {}) {
+    return http_1.default.delete(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/delete/${encodeURIComponent(filePath)}`,
+        ...options,
+    });
+}
+exports.deleteFile = deleteFile;
+// Moves file from srcPath to destPath
+async function moveFile(accountId, srcPath, destPath) {
+    return http_1.default.put(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/rename/${srcPath}?path=${destPath}`,
+    });
+}
+exports.moveFile = moveFile;
+// Get directory contents
+async function getDirectoryContentsByPath(accountId, path) {
+    return http_1.default.get(accountId, {
+        url: `${exports.FILE_MAPPER_API_PATH}/meta/${path}`,
+    });
+}
+exports.getDirectoryContentsByPath = getDirectoryContentsByPath;

package/api/functions.d.ts

@@ -0,0 +1,4 @@
+import { GetBuildStatusResponse, GetRoutesResponse } from '../types/Functions';
+export declare function getRoutes(accountId: number): Promise<GetRoutesResponse>;
+export declare function buildPackage(accountId: number, folderPath: string): Promise<string>;
+export declare function getBuildStatus(portalId: number, buildId: number): Promise<GetBuildStatusResponse>;

package/api/functions.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuildStatus = exports.buildPackage = exports.getRoutes = void 0;
+const http_1 = __importDefault(require("../http"));
+const FUNCTION_API_PATH = 'cms/v3/functions';
+async function getRoutes(accountId) {
+    return http_1.default.get(accountId, {
+        url: `${FUNCTION_API_PATH}/routes`,
+    });
+}
+exports.getRoutes = getRoutes;
+async function buildPackage(accountId, folderPath) {
+    return http_1.default.post(accountId, {
+        url: `${FUNCTION_API_PATH}/build/async`,
+        headers: {
+            Accept: 'text/plain',
+        },
+        body: {
+            folderPath,
+        },
+    });
+}
+exports.buildPackage = buildPackage;
+async function getBuildStatus(portalId, buildId) {
+    return http_1.default.get(portalId, {
+        url: `${FUNCTION_API_PATH}/build/${buildId}/poll`,
+    });
+}
+exports.getBuildStatus = getBuildStatus;

package/api/hubdb.d.ts

@@ -0,0 +1,10 @@
+import { QueryParams } from '../types/Http';
+import { CreateRowsResponse, FetchRowsResponse, Row, Schema, Table } from '../types/Hubdb';
+export declare function fetchTable(accountId: number, tableId: string): Promise<Table>;
+export declare function createTable(accountId: number, schema: Schema): Promise<Table>;
+export declare function updateTable(accountId: number, tableId: string, schema: Schema): Promise<unknown>;
+export declare function publishTable(accountId: number, tableId: string): Promise<Table>;
+export declare function deleteTable(accountId: number, tableId: string): Promise<void>;
+export declare function createRows(accountId: number, tableId: string, rows: Array<Row>): Promise<CreateRowsResponse>;
+export declare function fetchRows(accountId: number, tableId: string, query?: QueryParams): Promise<FetchRowsResponse>;
+export declare function deleteRows(accountId: number, tableId: string, rowIds: Array<string>): Promise<void>;

package/api/hubdb.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteRows = exports.fetchRows = exports.createRows = exports.deleteTable = exports.publishTable = exports.updateTable = exports.createTable = exports.fetchTable = void 0;
+const http_1 = __importDefault(require("../http"));
+const HUBDB_API_PATH = 'cms/v3/hubdb';
+async function fetchTable(accountId, tableId) {
+    return http_1.default.get(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}`,
+    });
+}
+exports.fetchTable = fetchTable;
+async function createTable(accountId, schema) {
+    return http_1.default.post(accountId, {
+        url: `${HUBDB_API_PATH}/tables`,
+        body: schema,
+    });
+}
+exports.createTable = createTable;
+async function updateTable(accountId, tableId, schema) {
+    return http_1.default.patch(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}/draft`,
+        body: schema,
+    });
+}
+exports.updateTable = updateTable;
+async function publishTable(accountId, tableId) {
+    return http_1.default.post(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}/draft/publish`,
+    });
+}
+exports.publishTable = publishTable;
+async function deleteTable(accountId, tableId) {
+    return http_1.default.delete(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}`,
+    });
+}
+exports.deleteTable = deleteTable;
+async function createRows(accountId, tableId, rows) {
+    return http_1.default.post(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}/rows/draft/batch/create`,
+        body: { inputs: rows },
+    });
+}
+exports.createRows = createRows;
+async function fetchRows(accountId, tableId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}/rows/draft`,
+        query,
+    });
+}
+exports.fetchRows = fetchRows;
+async function deleteRows(accountId, tableId, rowIds) {
+    return http_1.default.post(accountId, {
+        url: `${HUBDB_API_PATH}/tables/${tableId}/rows/draft/batch/purge`,
+        body: { inputs: rowIds },
+    });
+}
+exports.deleteRows = deleteRows;

package/api/lighthouseScore.d.ts

@@ -0,0 +1,5 @@
+import { Body, QueryParams } from '../types/Http';
+import { GetLighthouseScoreResponse, RequestLighthouseScoreResponse } from '../types/Lighthouse';
+export declare function requestLighthouseScore(accountId: number, body?: Body): Promise<RequestLighthouseScoreResponse>;
+export declare function getLighthouseScoreStatus(accountId: number, query?: QueryParams): Promise<string>;
+export declare function getLighthouseScore(accountId: number, query?: QueryParams): Promise<GetLighthouseScoreResponse>;

package/api/lighthouseScore.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLighthouseScore = exports.getLighthouseScoreStatus = exports.requestLighthouseScore = void 0;
+const http_1 = __importDefault(require("../http"));
+const LIGHTHOUSE_SCORE_API_BASE = 'quality-engine/v1/lighthouse';
+async function requestLighthouseScore(accountId, body = {}) {
+    return http_1.default.post(accountId, {
+        url: `${LIGHTHOUSE_SCORE_API_BASE}/request`,
+        body,
+    });
+}
+exports.requestLighthouseScore = requestLighthouseScore;
+async function getLighthouseScoreStatus(accountId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${LIGHTHOUSE_SCORE_API_BASE}/status`,
+        query,
+    });
+}
+exports.getLighthouseScoreStatus = getLighthouseScoreStatus;
+async function getLighthouseScore(accountId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${LIGHTHOUSE_SCORE_API_BASE}/scores`,
+        query,
+    });
+}
+exports.getLighthouseScore = getLighthouseScore;

package/api/localDevAuth.d.ts

@@ -0,0 +1,12 @@
+import { Environment } from '../types/Config';
+import { ScopeData } from '../types/Accounts';
+type AccessTokenResponse = {
+    hubId: number;
+    oauthAccessToken: string;
+    expiresAtMillis: number;
+    scopeGroups: Array<string>;
+    encodedOauthRefreshToken: string;
+};
+export declare function fetchAccessToken(personalAccessKey: string, env?: Environment, portalId?: number): Promise<AccessTokenResponse>;
+export declare function fetchScopeData(accountId: number, scopeGroup: string): Promise<ScopeData>;
+export {};

package/api/localDevAuth.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchScopeData = exports.fetchAccessToken = void 0;
+const getAxiosConfig_1 = require("../http/getAxiosConfig");
+const http_1 = __importDefault(require("../http"));
+const environments_1 = require("../constants/environments");
+const axios_1 = __importDefault(require("axios"));
+const LOCALDEVAUTH_API_AUTH_PATH = 'localdevauth/v1/auth';
+async function fetchAccessToken(personalAccessKey, env = environments_1.ENVIRONMENTS.PROD, portalId) {
+    const query = portalId ? { portalId } : {};
+    const axiosConfig = (0, getAxiosConfig_1.getAxiosConfig)({
+        env,
+        localHostOverride: true,
+        url: `${LOCALDEVAUTH_API_AUTH_PATH}/refresh`,
+        body: {
+            encodedOAuthRefreshToken: personalAccessKey,
+        },
+        params: query,
+    });
+    const { data } = await (0, axios_1.default)({
+        ...axiosConfig,
+        method: 'post',
+    });
+    return data;
+}
+exports.fetchAccessToken = fetchAccessToken;
+async function fetchScopeData(accountId, scopeGroup) {
+    return http_1.default.get(accountId, {
+        url: `localdevauth/v1/auth/check-scopes`,
+        query: {
+            scopeGroup,
+        },
+    });
+}
+exports.fetchScopeData = fetchScopeData;

package/api/marketplaceValidation.d.ts

@@ -0,0 +1,5 @@
+import { Body, QueryParams } from '../types/Http';
+import { GetValidationResultsResponse } from '../types/MarketplaceValidation';
+export declare function requestValidation(accountId: number, body?: Body): Promise<number>;
+export declare function getValidationStatus(accountId: number, query?: QueryParams): Promise<string>;
+export declare function getValidationResults(accountId: number, query?: QueryParams): Promise<GetValidationResultsResponse>;

package/api/marketplaceValidation.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidationResults = exports.getValidationStatus = exports.requestValidation = void 0;
+const http_1 = __importDefault(require("../http"));
+const VALIDATION_API_BASE = 'quality-engine/v1/validation';
+function requestValidation(accountId, body = {}) {
+    return http_1.default.post(accountId, {
+        url: `${VALIDATION_API_BASE}/request`,
+        body,
+    });
+}
+exports.requestValidation = requestValidation;
+function getValidationStatus(accountId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${VALIDATION_API_BASE}/status`,
+        query,
+    });
+}
+exports.getValidationStatus = getValidationStatus;
+function getValidationResults(accountId, query = {}) {
+    return http_1.default.get(accountId, {
+        url: `${VALIDATION_API_BASE}/results`,
+        query,
+    });
+}
+exports.getValidationResults = getValidationResults;

package/api/projects.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+import { QueryParams } from '../types/Http';
+import { Project, FetchProjectResponse, UploadProjectResponse, ProjectSettings } from '../types/Project';
+import { Build, FetchProjectBuildsResponse } from '../types/Build';
+import { ComponentMetadataResponse, ComponentStructureResponse } from '../types/ComponentStructure';
+import { Deploy, ProjectDeployResponse } from '../types/Deploy';
+export declare function fetchProjects(accountId: number): Promise<FetchProjectResponse>;
+export declare function createProject(accountId: number, name: string): Promise<Project>;
+export declare function uploadProject(accountId: number, projectName: string, projectFile: string, uploadMessage: string, platformVersion?: string): Promise<UploadProjectResponse>;
+export declare function fetchProject(accountId: number, projectName: string): Promise<Project>;
+export declare function downloadProject(accountId: number, projectName: string, buildId: number): Promise<Buffer>;
+export declare function deleteProject(accountId: number, projectName: string): Promise<void>;
+type FetchPlatformVersionResponse = {
+    defaultPlatformVersion: string;
+    activePlatformVersions: Array<string>;
+};
+export declare function fetchPlatformVersions(accountId: number): Promise<FetchPlatformVersionResponse>;
+export declare function fetchProjectBuilds(accountId: number, projectName: string, query: QueryParams): Promise<FetchProjectBuildsResponse>;
+export declare function getBuildStatus(accountId: number, projectName: string, buildId: number): Promise<Build>;
+export declare function getBuildStructure(accountId: number, projectName: string, buildId: number): Promise<ComponentStructureResponse>;
+export declare function deployProject(accountId: number, projectName: string, buildId: number): Promise<ProjectDeployResponse>;
+export declare function getDeployStatus(accountId: number, projectName: string, deployId: number): Promise<Deploy>;
+export declare function getDeployStructure(accountId: number, projectName: string, deployId: number): Promise<ComponentStructureResponse>;
+export declare function fetchProjectSettings(accountId: number, projectName: string): Promise<ProjectSettings>;
+export declare function fetchDeployComponentsMetadata(accountId: number, projectId: number): Promise<ComponentMetadataResponse>;
+export declare function cancelStagedBuild(accountId: number, projectName: string): Promise<void>;
+export {};