@ductape/sdk 0.0.4-v6 → 0.0.4-v61

package/dist/actions/utils/actions.util.read.js

@@ -1,427 +0,0 @@
-/*import { Categories, EntityTypes, Formats, ImportPostmanCollectionPayload, KeyValuePair, Modes, PostmanCollectionV21, PostmanFoldersV21, PostmanRequestV21, PostmanResponseV21, PostmanURLV21, ResponseFormats, ReturnTypes } from "../../types/actions.types";
-import { createApp } from "../../requests/apps.requests";
-import { createActions, createFolder, createResponse, updateActionData, updateEntityData } from "../../requests/actions.requests";
-import { tagify } from "../../config/constant";
-import { parseJSON } from "../../inputs/utils/inputs.utils.create";
-import { DataTypes, ExpectedValues } from "../../inputs/inputs.types";
-import { green as g, yellow as y, dim as d, red as r, blue as b } from 'chalk';
-
-// let showLogs = false;
-export const parsePostmanCollectionV21 = async (data: ImportPostmanCollectionPayload): Promise<void> => {
-
-    try {
-
-        const { collectionJSON: payload, user_id, public_key, token, workspace_id } = data;
-        // showLogs = logs;
-
-        let app_id = data.app_id;
-
-        const { item: items, info } = payload;
-
-        //console.log(payload)
-
-        const arr = [];
-
-        // //console.log(data)
-
-        // if(showLogs) //console.log(`${g(`PARSING AND UPLOADING POSTMAN COLLECTION V2.1 TO DUCTAPE ACTIONS`)}`)
-
-        if (info && !app_id) {
-            const { name: app_name, description } = info
-            // create app
-
-            console.log(`${g(`UPDATE:`)} ${`app_id not supplied, new app ${app_name} being created`}`)
-
-            const app_data = { token, user_id, app_name, public_key, workspace_id, description, returned: ReturnTypes.SINGLE }
-
-            //console.log(`${y(`INFO:`)} New App Data`, app_data);
-            const res = await createApp(app_data);
-
-            const app = res.data.data;
-
-            console.log(`${g(`UPDATE:`)} ${`New app ${app_name} created, app_id: ${y(app._id)}`}`)
-
-            app_id = app._id;
-
-        }
-        for (let i = 0; i < items.length; i++) {
-
-            const { name, item, request, response, description } = items[i]
-            if (name && item) {
-                const folder_data = {
-                    name,
-                    item,
-                    user_id,
-                    public_key,
-                    app_id,
-                    description,
-                    type: EntityTypes.FOLDER,
-                    level: 0,
-                    token
-                }
-                //console.log(`${g(`UPDATE:`)} ${`opening ${name} folder`}`, folder_data);
-                await parsePostmanFoldersV21(folder_data)
-            } else {
-                const action_data = {
-                    name,
-                    request,
-                    response,
-                    description,
-                    app_id,
-                    type: EntityTypes.ACTION,
-                    folder_id: "",
-                    token,
-                    public_key,
-                    user_id
-                }
-                //console.log(`${g(`UPDATE:`)} ${`parsing ${name} action`}`, action_data);
-                await parsePostmanActionV2(action_data);
-            }
-
-        }
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e)
-
-    }
-}
-
-export const parsePostmanFoldersV21 = async (payload: {
-    name: string;
-    item: Array<PostmanFoldersV21>;
-    user_id: string;
-    public_key: string;
-    app_id?: string;
-    description: string;
-    type: EntityTypes,
-    parent_folder_id?: string;
-    level: number;
-    token: string;
-}): Promise<void> => {
-
-    try {
-        const arr: any = []
-
-        const {
-            item: items,
-            user_id,
-            public_key,
-            app_id,
-            description,
-            name,
-            parent_folder_id,
-            level,
-            token
-        } = payload;
-
-        const create_payload = { name, app_id, public_key, description, user_id, parent_folder_id, level, token }
-
-        //console.log(`${g(`UPDATE:`)} ${`creating_folder ${name} folder`}`, create_payload);
-        const res = await createFolder(create_payload);
-
-        const folder_data = res.data.data
-        //console.log(`${y(`INFO:`)} New Folder Data`, folder_data);
-
-        const folder_id = folder_data._id
-
-        for (let i = 0; i < items.length; i++) {
-            const { name, item, request, response, description } = items[i]
-            if (name && item) {
-                const folder_data = {
-                    name,
-                    item,
-                    user_id,
-                    public_key,
-                    app_id,
-                    description,
-                    type: EntityTypes.FOLDER,
-                    parent_folder_id: folder_id,
-                    level: (level + 1),
-                    token
-                }
-                //console.log(`${g(`UPDATE:`)} ${`opening ${name} folder`}`, folder_data);
-                await parsePostmanFoldersV21(folder_data);
-            } else {
-                const action_data = {
-                    name,
-                    request,
-                    response,
-                    description,
-                    app_id,
-                    type: EntityTypes.ACTION,
-                    folder_id,
-                    user_id,
-                    public_key,
-                    token
-                }
-                //console.log(`${g(`UPDATE:`)} ${`parsing ${name} action`}`, action_data);
-                await parsePostmanActionV2(
-                    action_data
-                );
-            }
-        }
-
-
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e);
-    }
-}
-
-
-export const parsePostmanActionV2 = async (payload: {
-    name: string;
-    request: PostmanRequestV21;
-    response: Array<PostmanResponseV21>;
-    description: string;
-    app_id?: string;
-    type: EntityTypes;
-    folder_id: string;
-    public_key: string;
-    user_id: string;
-    token: string;
-}): Promise<void> => {
-    try {
-
-        const {
-            name,
-            request,
-            response,
-            description,
-            app_id,
-            folder_id,
-            public_key,
-            user_id,
-            token
-        } = payload;
-
-        //console.log(`${g(`UPDATE:`)} ${`extracting request data from ${name} action`}`, request);
-        const { resource, httpVerb, type } = extractActionDataV21(request);
-
-        //console.log(`${g(`UPDATE:`)} ${`extracted request data from ${name} action`}`, { resource, httpVerb, type });
-
-        const action_data = {
-            folder_id,
-            app_id,
-            name,
-            resource,
-            httpVerb,
-            type,
-            description,
-            tag: `${tagify(name)}_${Math.floor(Math.random() * 1000)}`,
-            public_key,
-            user_id,
-            token
-        }
-
-        console.log(`${g(`UPDATE:`)} ${`creating ${name} action`}`);
-        const res = await createActions(action_data);
-
-        console.log(`${y(`INFO:`)} New Action Data`, res.data.data);
-        const action_id = res.data.data._id;
-
-
-        const { body, header, url } = request;
-
-        //console.log(`${g(`UPDATE:`)} ${`parsing headers for ${name} action`}`, header)
-        await parsePostmanKeyValuePairsV21(header, { entity_id: action_id, user_id, token, public_key, category: Categories.HEADERS })
-
-
-        //console.log(`${g(`UPDATE:`)} ${`parsing url variables for ${name} action`}`, url)
-        await parsePostmanURLV21(url, { entity_id: action_id, user_id, token, public_key })
-
-        if (body) {
-            const { options, raw: rawData, mode } = body;
-            const { raw } = options;
-            const { language } = raw;
-
-            if (mode === Modes.RAW && language === Formats.JSON && rawData) {
-                const data = cleanRawJSONData(rawData);
-                //console.log(`${g(`UPDATE:`)} ${`parsing body variables for ${name} action`}`, body)
-                await parsePostmanBodyJSONV21(data, { entity_id: action_id, user_id, token, public_key, category: Categories.BODY });
-            }
-        }
-
-        await parsePostmanResponsesV21(response, { entity_id: action_id, user_id, token, public_key, category: Categories.RESPONSE })
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e)
-    }
-}
-
-export const parsePostmanURLV21 = async (data: PostmanURLV21, payload: { entity_id: string; user_id: string; public_key: string; token: string }) => {
-
-    try {
-        const { variable, query } = data;
-
-        if (query) {
-            //console.log(`${g(`UPDATE:`)} ${`parsing query`}`, query)
-            await parsePostmanKeyValuePairsV21(query, { ...payload, category: Categories.QUERY });
-        }
-        if (variable) {
-            //console.log(`${g(`UPDATE:`)} ${`parsing params`}`, variable)
-            await parsePostmanKeyValuePairsV21(variable, { ...payload, category: Categories.PARAMS });
-        }
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e);
-    }
-}
-
-export const parsePostmanKeyValuePairsV21 = async (data: Array<KeyValuePair>, payload: { entity_id: string; user_id: string; public_key: string; token: string, category: Categories }) => {
-
-    try {
-        const arr: any = [];
-
-        const { entity_id, user_id, public_key, token, category } = payload;
-        console.log(`${g(`UPDATE:`)} ${`parsing array of ${category}`}`)
-
-        for (let i = 0; i < data.length; i++) {
-
-            const { key, value, description } = data[i];
-
-            let type = typeof value;
-
-            // @ts-ignore
-            if (type == 'object' && Array.isArray(value)) type = 'array'
-
-            if (key) {
-                arr.push({
-                    key: key,
-                    category,
-                    sampleValue: value,
-                    description: description || '',
-                    required: true,
-                    maxLength: 0,
-                    minLength: 0,
-                    decorator: '',
-                    decoratorPosition: '',
-                    type,
-                    defaultType: 'input',
-                    defaultValue: '',
-                    index: i,
-                    parent_key: '',
-                    parent_index: 0,
-                    level: 0
-                })
-            }
-        }
-        console.log(`${g(`UPDATE:`)} ${`parsed array of ${category}`}`)
-        try {
-            await updateEntityData({ entity_id, user_id, public_key, data: arr, sample: JSON.stringify(data), token, category })
-        } catch (e) {
-            console.log(`${r(`ERROR CREATING DATA:`)} ${e.toString()} `)
-            console.log(e)
-
-        }
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e);
-    }
-}
-
-const parsePostmanBodyJSONV21 = async (data: object, payload: { entity_id: string; user_id: string; public_key: string; token: string, category: Categories }) => {
-
-    try {
-
-        const { entity_id, user_id, public_key, token, category } = payload;
-
-        console.log("JSON CATEGORY!!", category)
-        const parse_body = {
-            data,
-            parent_key: '',
-            level: 0,
-            parent_index: 0,
-            type: DataTypes.JSON,
-            expected: ExpectedValues.PARSESAMPLE,
-            category
-        }
-        //console.log(`${g(`UPDATE:`)} ${`parsing JSON object to ductape datapoints`}`, parse_body);
-        const arr = parseJSON(parse_body);
-        console.log(`${g(`UPDATE:`)} ${`parsed JSON object to ductape datapoints`}`, arr);
-        try {
-            await updateEntityData({ entity_id, user_id, public_key, data: arr, sample: JSON.stringify(data), token, category })
-        } catch (e) {
-            console.log(`${r(`ERROR CREATING DATA:`)} ${e.toString()} `)
-            console.log(e)
-        }
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e);
-
-    }
-}
-
-export const parsePostmanResponsesV21 = async (payload: Array<PostmanResponseV21>, data: { entity_id: string; user_id: string; public_key: string; token: string, category: Categories }) => {
-    //console.log(`${g(`UPDATE:`)} ${`parsing postman v2.1 responses`}`, payload);
-    for (let i = 0; i < payload.length; i++) {
-
-        const { entity_id, user_id, public_key, token, category } = data;
-        const { name, status, code, _postman_previewlanguage, body } = payload[i];
-
-        let response_format = _postman_previewlanguage;
-
-        if (_postman_previewlanguage === Formats.JSON) response_format = ResponseFormats.JSON;
-        const response_payload = {
-            public_key,
-            entity_id,
-            category,
-            user_id,
-            token,
-            response_format,
-            description: status,
-            name: `${tagify(name)}`,
-            tag: `${tagify(name)}_${Math.floor(Math.random() * 1000)}`,
-            success: false,
-            status_code: code? String(code): null,
-            returned: ReturnTypes.SINGLE
-        }
-        try {
-            console.log(`${g(`UPDATE:`)} ${`creating response`}`, response_payload);
-            const res = await createResponse(response_payload);
-            console.log(`${g(`UPDATE:`)} ${`response created for entitiy ${entity_id}`}`, res.data.data);
-            const { _id } = res.data.data
-
-            if (response_format === ResponseFormats.JSON) {
-                const data = cleanRawJSONData(body);
-                //console.log(`${g(`UPDATE:`)} ${`response body parsing`}`, data);
-                await parsePostmanBodyJSONV21(data, { entity_id: _id, user_id, token, public_key, category: Categories.RESPONSE });
-            }
-        } catch (e) {
-            console.log(`${r(`ERROR CREATING RESPONSE:`)} ${e.toString()} `)
-            console.log(e);
-        }
-
-    }
-}
-
-export const extractActionDataV21 = (request: PostmanRequestV21) => {
-
-    const { method: httpVerb, url } = request;
-    let resource = ''
-    if (url.path) resource = resourcifyPostmanURLArray(url.path);
-
-    return { httpVerb, resource, type: httpVerb }
-}
-
-const resourcifyPostmanURLArray = (url: Array<string>) => {
-    let str = "/";
-
-    url.map((data, index) => {
-        str = `${str}${data}`;
-
-        if (index !== url.length - 1) str = `${str}/`
-    });
-    return str;
-}
-
-const cleanRawJSONData = (data: string) => {
-    try {
-        return JSON.parse(data);
-    } catch (e) {
-        console.log(`${r(`ERROR:`)} ${e.toString()} `)
-        console.log(e);
-        console.log(data);
-    }
-}*/ 
-//# sourceMappingURL=actions.util.read.js.map

package/dist/actions/utils/actions.util.read.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"actions.util.read.js","sourceRoot":"","sources":["../../../src/actions/utils/actions.util.read.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyaG"}

package/dist/api/services/integrationsApi.service.d.ts

@@ -1,18 +0,0 @@
-import { PublicStates } from "../../types/enums";
-import { ICreateIntegrationsBuilder, ICreateIntegrationsPayload, IIntegration } from "../../types/integrationsBuilder.types";
-import { IRequestExtension } from "../../types/requests.types";
-export interface IIntegrationsApiService {
-    createIntegration(payload: ICreateIntegrationsBuilder, auth: IRequestExtension): Promise<IIntegration>;
-    updateIntegration(integration_id: string, payload: Record<string, unknown>, auth: IRequestExtension): Promise<void>;
-    checkIntegrationNameExists(name: string, auth: IRequestExtension): Promise<IIntegration>;
-    fetchIntegration(integration_id: string, auth: IRequestExtension): Promise<IIntegration>;
-    fetchWorkspaceIntegrations(status: PublicStates, payload: IRequestExtension): Promise<Array<IIntegration>>;
-}
-export declare class IntegrationsApiService implements IIntegrationsApiService {
-    constructor();
-    createIntegration(payload: ICreateIntegrationsPayload, auth: IRequestExtension): Promise<IIntegration>;
-    updateIntegration(integration_id: string, payload: Partial<ICreateIntegrationsPayload>, auth: IRequestExtension): Promise<void>;
-    fetchIntegration(integration_id: string, auth: IRequestExtension): Promise<IIntegration>;
-    checkIntegrationNameExists(name: string, auth: IRequestExtension): Promise<IIntegration>;
-    fetchWorkspaceIntegrations(status: PublicStates, payload: IRequestExtension): Promise<Array<IIntegration>>;
-}

package/dist/api/services/integrationsApi.service.js

@@ -1,80 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IntegrationsApiService = void 0;
-const integrations_client_1 = require("../../clients/integrations.client");
-const enums_1 = require("../../types/enums");
-const urls_1 = require("../urls");
-const auth_utils_1 = require("../utils/auth.utils");
-const strings_utils_1 = require("../utils/strings.utils");
-class IntegrationsApiService {
-    constructor() { }
-    async createIntegration(payload, auth) {
-        try {
-            const { token } = auth, userAuthData = __rest(auth, ["token"]);
-            const res = await (0, integrations_client_1.integrationsClient)().post(urls_1.INTEGRATIONS_CREATE_URL, Object.assign(Object.assign({}, payload), userAuthData), (0, auth_utils_1.generateAxiosConfig)(token, enums_1.DataFormats.JSON));
-            return res.data.data;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async updateIntegration(integration_id, payload, auth) {
-        try {
-            const URL = (0, strings_utils_1.Parameterize)(urls_1.INTEGRATION_CRUD_URL, ":integration_id", integration_id);
-            const { token } = auth, userAuthData = __rest(auth, ["token"]);
-            // console.log("PAYLOAD ====>>>>>",payload)
-            await (0, integrations_client_1.integrationsClient)().put(URL, Object.assign(Object.assign({}, payload), userAuthData), (0, auth_utils_1.generateAxiosConfig)(token, enums_1.DataFormats.JSON));
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async fetchIntegration(integration_id, auth) {
-        try {
-            let URL = (0, strings_utils_1.Parameterize)(urls_1.INTEGRATION_CRUD_URL, ":integration_id", integration_id);
-            URL = `${URL}?workspace_id=${auth.workspace_id}&public_key=${auth.public_key}&user_id=${auth.user_id}`;
-            const res = await (0, integrations_client_1.integrationsClient)().get(URL, (0, auth_utils_1.generateAxiosConfig)(auth.token, enums_1.DataFormats.JSON));
-            return res.data.data;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-    async checkIntegrationNameExists(name, auth) {
-        try {
-            const { token } = auth, userAuthData = __rest(auth, ["token"]);
-            const res = await (0, integrations_client_1.integrationsClient)().post(urls_1.CHECK_INTEGRATION_EXISTS, Object.assign({ name }, userAuthData), (0, auth_utils_1.generateAxiosConfig)(token, enums_1.DataFormats.JSON));
-            // console.log(res);
-            return res.data.data;
-        }
-        catch (e) {
-            // console.log(e);
-            throw e;
-        }
-    }
-    async fetchWorkspaceIntegrations(status, payload) {
-        try {
-            const { token, workspace_id, user_id, public_key } = payload;
-            let URL = (0, strings_utils_1.Parameterize)(urls_1.INTEGRATIONS_FETCH_URL, ':workspace_id', workspace_id);
-            URL = (0, strings_utils_1.Parameterize)(URL, ':status', status);
-            const res = await (0, integrations_client_1.integrationsClient)().get(`${URL}?user_id=${user_id}&public_key=${public_key}`, (0, auth_utils_1.generateAxiosConfig)(token, enums_1.DataFormats.JSON));
-            return res.data.data;
-        }
-        catch (e) {
-            throw e;
-        }
-    }
-}
-exports.IntegrationsApiService = IntegrationsApiService;
-//# sourceMappingURL=integrationsApi.service.js.map

package/dist/api/services/integrationsApi.service.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"integrationsApi.service.js","sourceRoot":"","sources":["../../../src/api/services/integrationsApi.service.ts"],"names":[],"mappings":"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"}

package/dist/appBuilder/services/app.service.d.ts

@@ -1,111 +0,0 @@
-import { IApp, ICreateAppBuilder, IAppEnv, IAppAction, IAppActionBody, IAppActionResponseInfo, IAppAuth, IAppEvent, ISample, IAppVariables, IAppConstants } from '../../types/appBuilder.types';
-import { IParsedSample } from '../../types/inputs.types';
-import { Categories, RequestAction } from '../../types/enums';
-import { IBuilderInit } from '../../types/index.types';
-export interface IAppBuilderService {
-    createApp({ app_name, description }: ICreateAppBuilder): Promise<{
-        app_id: string;
-    }>;
-    fetchApp(): IApp;
-    initializeApp(app_id: string): Promise<void>;
-    initializeAppByName(app_name: string): Promise<void>;
-    initializeAppByTag(app_tag: string): Promise<void>;
-    updateApp(data: Partial<IApp>): Promise<void>;
-    createEnv(data: IAppEnv): Promise<void>;
-    updateEnv(slug: string, data: Partial<IAppEnv>): Promise<void>;
-    fetchEnvs(): IAppEnv[];
-    fetchEnv(slug: string): IAppEnv;
-    updateDataValidation(locator: string, update: Partial<IParsedSample>): Promise<void>;
-    updateAction(tag: string, data: Partial<IAppAction>): Promise<void>;
-    fetchAction(identifier: string): IAppAction;
-    fetchActions(): Array<IAppAction>;
-    createAuth(data: Partial<IAppAuth>): Promise<void>;
-    updateAuth(tag: string, data: Partial<IAppAuth>): Promise<void>;
-    fetchAuth(tag: string): IAppAuth;
-    fetchAuths(): Array<IAppAuth>;
-    createEvent(data: Partial<IAppEvent>): Promise<void>;
-    updateEvent(tag: string, data: Partial<IAppEvent>): Promise<void>;
-    fetchEvent(tag: string): IAppEvent;
-    fetchEvents(): Array<IAppEvent>;
-    checkIfAppExists(app_name: string): Promise<IApp | false>;
-    parseResponsePayload(payload: IAppActionResponseInfo): Promise<IAppActionResponseInfo>;
-    parseRequestData(category: Categories, payload: ISample): Promise<ISample>;
-    extractResourceData(url: string): Promise<{
-        query: Partial<ISample>;
-        params: Partial<ISample>;
-    }>;
-    createConstant(data: Partial<IAppConstants>): Promise<void>;
-    updateConstant(key: string, data: Partial<IAppConstants>): Promise<void>;
-    fetchConstants(): Array<IAppConstants>;
-    fetchConstant(key: string): IAppConstants;
-    createVariable(data: Partial<IAppVariables>): Promise<void>;
-    updateVariable(key: string, data: Partial<IAppVariables>): Promise<void>;
-    fetchVariables(): Array<IAppVariables>;
-    fetchVariable(key: string): IAppVariables;
-}
-export default class AppBuilderService implements IAppBuilderService {
-    private user_id;
-    private workspace_id;
-    private token;
-    private app_id;
-    private public_key;
-    private app;
-    private workspace;
-    private appApi;
-    private workspaceApi;
-    private inputsService;
-    constructor({ workspace_id, public_key, user_id, token }: IBuilderInit);
-    createApp(data: ICreateAppBuilder): Promise<{
-        app_id: string;
-    }>;
-    initializeAppByTag(app_tag: string): Promise<void>;
-    initializeApp(app_id: string): Promise<void>;
-    initializeWorkspace(): Promise<void>;
-    private createNewApp;
-    initializeAppByName(app_name: string): Promise<void>;
-    checkIfAppExists(app_name: string): Promise<IApp | false>;
-    fetchApp(): IApp;
-    updateApp(data: Partial<IApp>): Promise<void>;
-    createEnv(data: IAppEnv, throwErrorIfExists?: boolean): Promise<void>;
-    updateEnv(slug: string, data: Partial<IAppEnv>): Promise<void>;
-    fetchEnvs(): IAppEnv[];
-    fetchEnv(slug: string, throwErrorIfExists?: boolean): IAppEnv;
-    extractResourceData(url: string): Promise<{
-        query: Partial<ISample>;
-        params: Partial<ISample>;
-    }>;
-    createAction(data: Omit<IAppAction, 'app_id' & 'user_id'>, throwErrorIfExists?: boolean): Promise<void>;
-    fetchActions(): Array<IAppAction>;
-    fetchAction(identifier: string): IAppAction;
-    updateAction(tag: string, data: Partial<IAppAction>): Promise<void>;
-    updateActionProcess(tag: string, data: Partial<IAppAction>, action: RequestAction): Promise<void>;
-    createActionRequestData(category: Categories, tag: string, payload: IAppActionBody, throwErrorIfExists?: boolean): Promise<void>;
-    parseRequestData(category: Categories, payload: ISample): Promise<ISample>;
-    fetchActionRequestData(category: Categories, tag: string): Array<IParsedSample>;
-    fetchActionRequestSample(category: Categories, tag: string): object | string;
-    updateRequestDataValidation(category: Categories, action_tag: string, body: Array<Partial<IParsedSample>>): Promise<void>;
-    createAppActionResponse(action_tag: string, payload: IAppActionResponseInfo): Promise<void>;
-    parseResponsePayload(payload: IAppActionResponseInfo): Promise<IAppActionResponseInfo>;
-    fetchAppActionResponse(action_tag: string, response_tag: string, throwErrorIfExists?: boolean): IAppActionResponseInfo;
-    extractEventData(data: Partial<IAppEvent>): Promise<Partial<IAppEvent>>;
-    createEvent(data: Partial<IAppEvent>): Promise<void>;
-    updateEvent(tag: string, data: Partial<IAppEvent>): Promise<void>;
-    fetchEvents(): Array<IAppEvent>;
-    fetchEvent(tag: string): IAppEvent;
-    extractAuthData(data: Partial<IAppAuth>): Promise<Partial<IAppAuth>>;
-    createAuth(data: Partial<IAppAuth>): Promise<void>;
-    updateAuth(tag: string, data: Partial<IAppAuth>): Promise<void>;
-    fetchAuths(): Array<IAppAuth>;
-    fetchAuth(tag: string): IAppAuth;
-    createVariable(data: Partial<IAppVariables>, throwErrorIfExists?: boolean): Promise<void>;
-    updateVariable(key: string, data: Partial<IAppVariables>): Promise<void>;
-    fetchVariables(): Array<IAppVariables>;
-    fetchVariable(key: string, throwErrorIfExists?: boolean): IAppVariables;
-    createConstant(data: Partial<IAppConstants>, throwErrorIfExists?: boolean): Promise<void>;
-    updateConstant(key: string, data: Partial<IAppConstants>): Promise<void>;
-    fetchConstants(): Array<IAppConstants>;
-    fetchConstant(key: string, throwErrorIfExists?: boolean): IAppConstants;
-    updateDataValidation(locator: string, update: Partial<IParsedSample>): Promise<void>;
-    private updateValidation;
-    private getUserAccess;
-}