@vtex/api 6.48.1-beta → 6.48.1-beta.2

package/lib/clients/external/ID.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ID = void 0;
+const ExternalClient_1 = require("./ExternalClient");
+const routes = {
+    SEND: '/accesskey/send',
+    START: '/start',
+    VALIDATE: '/accesskey/validate',
+    VALIDATE_CLASSIC: '/classic/validate',
+};
+const VTEXID_ENDPOINTS = {
+    STABLE: 'https://vtexid.vtex.com.br/api/vtexid/pub/authentication',
+};
+const endpoint = (env) => {
+    return VTEXID_ENDPOINTS[env] || env;
+};
+class ID extends ExternalClient_1.ExternalClient {
+    constructor(context, opts) {
+        super(endpoint(VTEXID_ENDPOINTS.STABLE), context, opts);
+        this.getTemporaryToken = (tracingConfig) => {
+            const metric = 'vtexid-temp-token';
+            return this.http.get(routes.START, { metric, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } }).then(({ authenticationToken }) => authenticationToken);
+        };
+        this.sendCodeToEmail = (token, email, tracingConfig) => {
+            const params = { authenticationToken: token, email };
+            const metric = 'vtexid-send-code';
+            return this.http.get(routes.SEND, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getEmailCodeAuthenticationToken = (token, email, code, tracingConfig) => {
+            const params = {
+                accesskey: code,
+                authenticationToken: token,
+                login: email,
+            };
+            const metric = 'vtexid-email-token';
+            return this.http.get(routes.VALIDATE, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+        this.getPasswordAuthenticationToken = (token, email, password, tracingConfig) => {
+            const params = {
+                authenticationToken: token,
+                login: email,
+                password,
+            };
+            const metric = 'vtexid-pass-token';
+            return this.http.get(routes.VALIDATE_CLASSIC, { metric, params, tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                } });
+        };
+    }
+}
+exports.ID = ID;

package/lib/clients/external/Masterdata.d.ts

@@ -0,0 +1,94 @@
+import { InstanceOptions, IOContext, RequestTracingConfig } from '../..';
+import { ExternalClient } from './ExternalClient';
+export declare class MasterData extends ExternalClient {
+    constructor(ctx: IOContext, options?: InstanceOptions);
+    getSchema<T>({ dataEntity, schema }: GetSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    createOrUpdateSchema<T>({ dataEntity, schemaName, schemaBody }: CreateSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    getPublicSchema<T>({ dataEntity, schema }: GetSchemaInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    getDocument<T>({ dataEntity, id, fields }: GetDocumentInput, tracingConfig?: RequestTracingConfig): Promise<T>;
+    createDocument({ dataEntity, fields, schema }: CreateDocumentInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    createOrUpdateEntireDocument({ dataEntity, fields, id, schema }: CreateOrUpdateInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    createOrUpdatePartialDocument({ dataEntity, fields, id, schema }: CreateOrUpdateInput, tracingConfig?: RequestTracingConfig): Promise<DocumentResponse>;
+    updateEntireDocument({ dataEntity, id, fields, schema }: UpdateInput, tracingConfig?: RequestTracingConfig): Promise<void>;
+    updatePartialDocument({ dataEntity, id, fields, schema }: UpdateInput, tracingConfig?: RequestTracingConfig): Promise<void>;
+    searchDocuments<T>({ dataEntity, fields, where, pagination, schema, sort }: SearchInput, tracingConfig?: RequestTracingConfig): Promise<T[]>;
+    searchDocumentsWithPaginationInfo<T>({ dataEntity, fields, where, pagination, schema, sort }: SearchInput, tracingConfig?: RequestTracingConfig): Promise<{
+        data: T[];
+        pagination: {
+            total: number;
+            page: number;
+            pageSize: number;
+        };
+    }>;
+    scrollDocuments<T>({ dataEntity, fields, where, mdToken, schema, size, sort }: ScrollInput, tracingConfig?: RequestTracingConfig): Promise<{
+        mdToken: string;
+        data: ScrollResponse<T>;
+    }>;
+    deleteDocument({ dataEntity, id }: DeleteInput, tracingConfig?: RequestTracingConfig): Promise<import("../..").IOResponse<void>>;
+}
+interface PaginationArgs {
+    page: number;
+    pageSize: number;
+}
+interface DocumentResponse {
+    Id: string;
+    Href: string;
+    DocumentId: string;
+}
+interface GetSchemaInput {
+    dataEntity: string;
+    schema: string;
+}
+interface CreateSchemaInput {
+    dataEntity: string;
+    schemaName: string;
+    schemaBody: object;
+}
+interface GetDocumentInput {
+    dataEntity: string;
+    id: string;
+    fields: string[];
+}
+interface CreateDocumentInput {
+    dataEntity: string;
+    fields: object;
+    schema?: string;
+}
+interface CreateOrUpdateInput {
+    dataEntity: string;
+    fields: object;
+    id?: string;
+    schema?: string;
+}
+interface UpdateInput {
+    dataEntity: string;
+    id: string;
+    fields: object;
+    schema?: string;
+}
+interface SearchInput {
+    dataEntity: string;
+    fields: string[];
+    where?: string;
+    pagination: PaginationArgs;
+    schema?: string;
+    sort?: string;
+}
+interface ScrollInput {
+    dataEntity: string;
+    fields: string[];
+    where?: string;
+    schema?: string;
+    sort?: string;
+    size?: number;
+    mdToken?: string;
+}
+interface DeleteInput {
+    dataEntity: string;
+    id: string;
+}
+interface ScrollResponse<T> {
+    data: T[];
+    mdToken: string;
+}
+export {};

package/lib/clients/external/Masterdata.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MasterData = void 0;
+const __1 = require("../..");
+const HttpClient_1 = require("../../HttpClient");
+const ExternalClient_1 = require("./ExternalClient");
+const routes = {
+    document: (dataEntity, id) => `${dataEntity}/documents/${id}`,
+    documents: (dataEntity) => `${dataEntity}/documents`,
+    publicSchema: (dataEntity, schema) => `${dataEntity}/schemas/${schema}/public`,
+    schema: (dataEntity, schema) => `${dataEntity}/schemas/${schema}`,
+    scroll: (dataEntity) => `${dataEntity}/scroll`,
+    search: (dataEntity) => `${dataEntity}/search`,
+};
+class MasterData extends ExternalClient_1.ExternalClient {
+    constructor(ctx, options) {
+        super(`http://api.vtex.com/api/dataentities`, ctx, {
+            ...options,
+            headers: {
+                Accept: 'application/json',
+                VtexIdclientAutCookie: ctx.authToken,
+                'x-vtex-api-appService': ctx.userAgent,
+                ...options === null || options === void 0 ? void 0 : options.headers,
+            },
+            params: {
+                an: ctx.account,
+                ...options === null || options === void 0 ? void 0 : options.params,
+            },
+        });
+    }
+    getSchema({ dataEntity, schema }, tracingConfig) {
+        const metric = 'masterdata-getSchema';
+        return this.http.get(routes.schema(dataEntity, schema), {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    createOrUpdateSchema({ dataEntity, schemaName, schemaBody }, tracingConfig) {
+        const metric = 'masterdata-createOrUpdateSchema';
+        return this.http.put(routes.schema(dataEntity, schemaName), schemaBody, {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    getPublicSchema({ dataEntity, schema }, tracingConfig) {
+        const metric = 'masterdata-getPublicSchema';
+        return this.http.get(routes.publicSchema(dataEntity, schema), {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    getDocument({ dataEntity, id, fields }, tracingConfig) {
+        const metric = 'masterdata-getDocument';
+        return this.http.get(routes.document(dataEntity, id), {
+            metric,
+            params: {
+                _fields: generateFieldsArg(fields),
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    createDocument({ dataEntity, fields, schema }, tracingConfig) {
+        const metric = 'masterdata-createDocument';
+        return this.http.post(routes.documents(dataEntity), fields, {
+            metric,
+            params: {
+                _schema: schema,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    createOrUpdateEntireDocument({ dataEntity, fields, id, schema }, tracingConfig) {
+        const metric = 'masterdata-createOrUpdateEntireDocument';
+        return this.http.put(routes.documents(dataEntity), { id, ...fields }, {
+            metric,
+            params: {
+                _schema: schema,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    createOrUpdatePartialDocument({ dataEntity, fields, id, schema }, tracingConfig) {
+        const metric = 'masterdata-createOrUpdatePartialDocument';
+        return this.http.patch(routes.documents(dataEntity), { id, ...fields }, {
+            metric,
+            params: {
+                _schema: schema,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    updateEntireDocument({ dataEntity, id, fields, schema }, tracingConfig) {
+        const metric = 'masterdata-updateEntireDocument';
+        return this.http.put(routes.document(dataEntity, id), fields, {
+            metric,
+            params: {
+                _schema: schema,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    updatePartialDocument({ dataEntity, id, fields, schema }, tracingConfig) {
+        const metric = 'masterdata-updatePartialDocument';
+        return this.http.patch(routes.document(dataEntity, id), fields, {
+            metric,
+            params: {
+                _schema: schema,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    searchDocuments({ dataEntity, fields, where, pagination, schema, sort }, tracingConfig) {
+        const metric = 'masterdata-searchDocuments';
+        return this.http.get(routes.search(dataEntity), {
+            cacheable: HttpClient_1.CacheType.None,
+            headers: paginationArgsToHeaders(pagination),
+            metric,
+            params: {
+                _fields: generateFieldsArg(fields),
+                _schema: schema,
+                _sort: sort,
+                _where: where,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+    async searchDocumentsWithPaginationInfo({ dataEntity, fields, where, pagination, schema, sort }, tracingConfig) {
+        const metric = 'masterdata-searchDocumentsWithPagination';
+        const result = await this.http.getRaw(routes.search(dataEntity), {
+            cacheable: HttpClient_1.CacheType.None,
+            headers: paginationArgsToHeaders(pagination),
+            metric,
+            params: {
+                _fields: generateFieldsArg(fields),
+                _schema: schema,
+                _sort: sort,
+                _where: where,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+        const headers = result.headers;
+        const restContentRange = headers['rest-content-range'];
+        const total = Number(restContentRange.split('/')[1]);
+        const paginationInfo = { ...pagination, total };
+        return { data: result.data, pagination: paginationInfo };
+    }
+    scrollDocuments({ dataEntity, fields, where, mdToken, schema, size, sort }, tracingConfig) {
+        const metric = 'masterdata-scrollDocuments';
+        return this.http
+            .getRaw(routes.scroll(dataEntity), {
+            cacheable: HttpClient_1.CacheType.None,
+            metric,
+            params: {
+                _fields: generateFieldsArg(fields),
+                _schema: schema,
+                _size: size,
+                _sort: sort,
+                _token: mdToken,
+                _where: where,
+            },
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        })
+            .then(({ headers: { 'x-vtex-md-token': resToken }, data }) => ({ mdToken: resToken, data }));
+    }
+    deleteDocument({ dataEntity, id }, tracingConfig) {
+        const metric = 'masterdata-deleteDocument';
+        return this.http.delete(routes.document(dataEntity, id), {
+            metric,
+            tracing: {
+                requestSpanNameSuffix: metric,
+                ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+            },
+        });
+    }
+}
+exports.MasterData = MasterData;
+function paginationArgsToHeaders({ page, pageSize }) {
+    if (page < 1) {
+        throw new __1.UserInputError('Smallest page value is 1');
+    }
+    const startIndex = (page - 1) * pageSize;
+    const endIndex = startIndex + pageSize;
+    return {
+        'REST-Range': `resources=${startIndex}-${endIndex}`,
+    };
+}
+function generateFieldsArg(fields) {
+    return fields.join(',');
+}

package/lib/clients/external/PaymentProvider.d.ts

@@ -0,0 +1,31 @@
+import { InstanceOptions, IOContext, Maybe } from '../..';
+import { RequestTracingConfig } from '../../HttpClient';
+import { ExternalClient } from './ExternalClient';
+export declare class PaymentProvider extends ExternalClient {
+    protected context: IOContext;
+    constructor(context: IOContext, options?: InstanceOptions);
+    callback: (transactionId: string, paymentId: string, callback: AuthorizationCallback, tracingConfig?: RequestTracingConfig) => Promise<unknown>;
+    inbound: <TRequest, TResponse>(transactionId: string, paymentId: string, action: string, payload: TRequest, tracingConfig?: RequestTracingConfig) => Promise<TResponse>;
+}
+export interface AuthorizationCallback {
+    paymentId: string;
+    status: string;
+    tid: string;
+    authorizationId?: Maybe<string>;
+    nsu?: Maybe<string>;
+    acquirer: string;
+    paymentUrl?: Maybe<string>;
+    paymentAppData?: Maybe<{
+        appName: string;
+        payload: string;
+    }>;
+    identificationNumber?: Maybe<string>;
+    identificationNumberFormatted?: Maybe<string>;
+    barCodeImageType?: Maybe<string>;
+    barCodeImageNumber?: Maybe<string>;
+    code?: Maybe<string>;
+    message?: Maybe<string>;
+    delayToAutoSettle?: Maybe<number>;
+    delayToAutoSettleAfterAntifraud?: Maybe<number>;
+    delayToCancel?: Maybe<number>;
+}

package/lib/clients/external/PaymentProvider.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentProvider = void 0;
+const ExternalClient_1 = require("./ExternalClient");
+const routes = {
+    callback: (transactionId, paymentId) => `${routes.payment(transactionId, paymentId)}/notification`,
+    inbound: (transactionId, paymentId, action) => `${routes.payment(transactionId, paymentId)}/inbound-request/${action}`,
+    payment: (transactionId, paymentId) => `/transactions/${transactionId}/payments/${paymentId}`,
+};
+class PaymentProvider extends ExternalClient_1.ExternalClient {
+    constructor(context, options) {
+        var _a;
+        super(`http://${context.account}.vtexpayments.com.br/payment-provider`, context, {
+            ...(options !== null && options !== void 0 ? options : {}),
+            headers: {
+                ...((_a = options === null || options === void 0 ? void 0 : options.headers) !== null && _a !== void 0 ? _a : {}),
+                'X-Vtex-Use-Https': 'true',
+            },
+        });
+        this.context = context;
+        this.callback = (transactionId, paymentId, callback, tracingConfig) => {
+            const metric = 'gateway-callback';
+            return this.http.post(routes.callback(transactionId, paymentId), callback, {
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+        this.inbound = (transactionId, paymentId, action, payload, tracingConfig) => {
+            const metric = 'gateway-inbound-request';
+            return this.http.post(routes.inbound(transactionId, paymentId, action), payload, {
+                metric,
+                tracing: {
+                    requestSpanNameSuffix: metric,
+                    ...tracingConfig === null || tracingConfig === void 0 ? void 0 : tracingConfig.tracing,
+                },
+            });
+        };
+    }
+}
+exports.PaymentProvider = PaymentProvider;

package/lib/clients/external/index.d.ts

@@ -0,0 +1,4 @@
+export * from './ExternalClient';
+export * from './ID';
+export * from './PaymentProvider';
+export * from './Masterdata';

package/lib/clients/external/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ExternalClient"), exports);
+__exportStar(require("./ID"), exports);
+__exportStar(require("./PaymentProvider"), exports);
+__exportStar(require("./Masterdata"), exports);

package/lib/clients/index.d.ts

@@ -1,21 +1,9 @@
-export * from './Apps';
-export * from './Assets';
-export * from './Billing';
-export * from './BillingMetrics';
-export * from './Builder';
-export * from './Events';
-export * from './Housekeeper';
-export * from './ID';
-export * from './LicenseManager';
-export * from './Logger';
-export * from './Messages';
-export * from './MessagesGraphQL';
-export * from './Metadata';
-export * from './Registry';
-export * from './Router';
-export * from './Segment';
-export * from './Settings';
-export * from './Session';
-export * from './Sphinx';
-export * from './VBase';
-export * from './Workspaces';
+export * from './apps';
+export * from './external';
+export * from './infra';
+export * from './janus';
+export * from './IOClient';
+export * from './IOClients';
+export * from './IOGraphQLClient';
+import promclient from 'prom-client';
+export { promclient };

package/lib/clients/index.js

@@ -1,26 +1,29 @@
 "use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./Apps"));
-__export(require("./Assets"));
-__export(require("./Billing"));
-__export(require("./BillingMetrics"));
-__export(require("./Builder"));
-__export(require("./Events"));
-__export(require("./Housekeeper"));
-__export(require("./ID"));
-__export(require("./LicenseManager"));
-__export(require("./Logger"));
-__export(require("./Messages"));
-__export(require("./MessagesGraphQL"));
-__export(require("./Metadata"));
-__export(require("./Registry"));
-__export(require("./Router"));
-__export(require("./Segment"));
-__export(require("./Settings"));
-__export(require("./Session"));
-__export(require("./Sphinx"));
-__export(require("./VBase"));
-__export(require("./Workspaces"));
+exports.promclient = void 0;
+__exportStar(require("./apps"), exports);
+__exportStar(require("./external"), exports);
+__exportStar(require("./infra"), exports);
+__exportStar(require("./janus"), exports);
+__exportStar(require("./IOClient"), exports);
+__exportStar(require("./IOClients"), exports);
+__exportStar(require("./IOGraphQLClient"), exports);
+const prom_client_1 = __importDefault(require("prom-client"));
+exports.promclient = prom_client_1.default;

package/lib/clients/infra/Apps.d.ts

@@ -0,0 +1,93 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { InstanceOptions, RequestTracingConfig } from '../../HttpClient';
+import { AppFilesList, AppManifest } from '../../responses';
+import { IOContext } from '../../service/worker/runtime/typings';
+import { InfraClient } from './InfraClient';
+export declare class Apps extends InfraClient {
+    private _routes;
+    private diskCache;
+    private memoryCache;
+    private get routes();
+    constructor(context: IOContext, options?: InstanceOptions);
+    installApp: (descriptor: string, tracingConfig?: RequestTracingConfig) => Promise<void> | Promise<AppInstallResponse>;
+    uninstallApp: (app: string, tracingConfig?: RequestTracingConfig) => Promise<import("../..").IOResponse<void>>;
+    acknowledgeApp: (app: string, service: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    link: (app: string, files: Change[], { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig) => Promise<import("../..").AppBundleResponse & {
+        bundleSize?: number | undefined;
+    }>;
+    patch: (app: string, changes: Change[], { zlib }?: ZipOptions, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    unlink: (app: string, tracingConfig?: RequestTracingConfig) => Promise<import("../..").IOResponse<void>>;
+    unlinkAll: (tracingConfig?: RequestTracingConfig) => Promise<import("../..").IOResponse<void>>;
+    saveAppSettings: (app: string, settings: any, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    listApps: ({ oldVersion, since, service }?: ListAppsOptions, tracingConfig?: RequestTracingConfig) => Promise<AppsList>;
+    listAppFiles: (app: string, { prefix, nextMarker }?: ListFilesOptions, tracingConfig?: RequestTracingConfig) => Promise<AppFilesList>;
+    listLinks: (tracingConfig?: RequestTracingConfig) => Promise<string[]>;
+    getAppFile: (app: string, path: string, staleIfError?: boolean, tracingConfig?: RequestTracingConfig) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppJSON: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean, tracingConfig?: RequestTracingConfig) => Promise<T>;
+    getFileFromApps: <T extends object | null>(app: string, path: string, nullIfNotFound?: boolean, tracingConfig?: RequestTracingConfig) => Promise<T>;
+    getAppFileStream: (app: string, path: string, tracingConfig?: RequestTracingConfig) => Promise<IncomingMessage>;
+    getApp: (app: string, tracingConfig?: RequestTracingConfig) => Promise<AppManifest>;
+    getAppSettings: (app: string, tracingConfig?: RequestTracingConfig) => Promise<any>;
+    getAllAppsSettings: (listAppsOptions?: ListAppsOptions, tracingConfig?: RequestTracingConfig) => Promise<AppsSettings>;
+    getAppBundle: (app: string, bundlePath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig) => Promise<Readable>;
+    unpackAppBundle: (app: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean, tracingConfig?: RequestTracingConfig) => Promise<Writable>;
+    getAppsMetaInfos: (filter?: string, staleWhileRevalidate?: boolean, tracingConfig?: RequestTracingConfig) => Promise<AppMetaInfo[]>;
+    getDependencies: (filter?: string, tracingConfig?: RequestTracingConfig) => Promise<Record<string, string[]>>;
+    updateDependencies: (tracingConfig?: RequestTracingConfig) => Promise<Record<string, string[]>>;
+    updateDependency: (name: string, version: string, registry: string, tracingConfig?: RequestTracingConfig) => Promise<void>;
+    resolveDependencies: (apps: string[], registries: string[], filter?: string, tracingConfig?: RequestTracingConfig) => Promise<any>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string, tracingConfig?: RequestTracingConfig) => Promise<Record<string, string[]>>;
+    private installRuntime;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+export interface AppMetaInfo {
+    id: string;
+    settingsSchema?: Record<string, any>;
+    _resolvedDependencies: Record<string, string>;
+    _isRoot: boolean;
+    _buildFeatures: Record<string, string[]>;
+}
+export interface WorkspaceMetaInfo {
+    apps: AppMetaInfo[];
+}
+export interface AppsListItem {
+    app: string;
+    id: string;
+    location: string;
+}
+export interface AppsList {
+    data: AppsListItem[];
+}
+export interface Change {
+    path: string;
+    content: string | Readable | Buffer;
+}
+export interface ListAppsOptions {
+    oldVersion?: string;
+    context?: string[];
+    since?: string;
+    service?: string;
+}
+export interface ListFilesOptions {
+    prefix?: string;
+    context?: string[];
+    nextMarker?: string;
+}
+export interface AppsSettings {
+    [app: string]: any;
+}
+export interface AppInstallResponse {
+    message: string;
+}
+export {};