@vtex/api 1.9.3 → 1.9.4

package/CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [1.9.4] - 2022-04-18
+
 ## [1.9.3] - 2022-04-14
 ### Fixed
 - Update sensitive fields.

package/lib/Apps.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+import { IncomingMessage } from 'http';
+import { Readable, Writable } from 'stream';
+import { ZlibOptions } from 'zlib';
+import { IODataSource } from './IODataSource';
+import { AppBundleLinked, AppFilesList, AppManifest } from './responses';
+export declare class Apps extends IODataSource {
+    protected httpClientFactory: import("./IODataSource").HttpClientFactory;
+    protected service: string;
+    installApp: (descriptor: string) => Promise<void>;
+    uninstallApp: (app: string) => Promise<import("./HttpClient").IOResponse<void>>;
+    acknowledgeApp: (app: string, service: string) => Promise<void>;
+    link: (app: string, files: Change[], { zlib }?: ZipOptions) => Promise<AppBundleLinked>;
+    patch: (app: string, changes: Change[], { zlib }?: ZipOptions) => Promise<void>;
+    unlink: (app: string) => Promise<import("./HttpClient").IOResponse<void>>;
+    unlinkAll: () => Promise<import("./HttpClient").IOResponse<void>>;
+    saveAppSettings: (app: string, settings: any) => Promise<void>;
+    listApps: ({ oldVersion, context, since, service }?: ListAppsOptions) => Promise<AppsList>;
+    listAppFiles: (app: string, { prefix, context, nextMarker }?: ListFilesOptions) => Promise<AppFilesList>;
+    listLinks: () => Promise<string[]>;
+    getAppFile: (app: string, path: string, context?: string[]) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getAppFileStream: (app: string, path: string, context?: string[]) => Promise<IncomingMessage>;
+    getApp: (app: string, context?: string[]) => Promise<AppManifest>;
+    getAppSettings: (app: string) => Promise<any>;
+    getAllAppsSettings: (listAppsOptions?: ListAppsOptions) => Promise<AppsSettings>;
+    getAppBundle: (app: string, bundlePath: string, generatePackageJson: boolean) => Promise<Readable>;
+    unpackAppBundle: (app: string, bundlePath: string, unpackPath: string, generatePackageJson: boolean) => Promise<Writable>;
+    getDependencies: (filter?: string) => Promise<Record<string, string[]>>;
+    updateDependencies: () => Promise<Record<string, string[]>>;
+    updateDependency: (name: string, version: string, registry: string) => Promise<void>;
+    resolveDependencies: (apps: string[], registries: string[], filter?: string) => Promise<any>;
+    resolveDependenciesWithManifest: (manifest: AppManifest, filter?: string) => Promise<Record<string, string[]>>;
+}
+interface ZipOptions {
+    zlib?: ZlibOptions;
+}
+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 {};

package/lib/Apps.js

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const archiver = require("archiver");
+const qs_1 = require("qs");
+const tar_fs_1 = require("tar-fs");
+const zlib_1 = require("zlib");
+const IODataSource_1 = require("./IODataSource");
+const routes = {
+    Acknowledge: (app, service) => `${routes.App(app)}/acknowledge/${service}`,
+    App: (app) => `${routes.Apps}/${app}`,
+    AppBundle: (app, path) => `${routes.App(app)}/bundle/${path}`,
+    Apps: '/apps',
+    Dependencies: '/dependencies',
+    File: (app, path) => `${routes.Files(app)}/${path}`,
+    Files: (app) => `${routes.App(app)}/files`,
+    Link: (app) => `/v2/links/${app}`,
+    Links: '/links',
+    ResolveDependencies: 'dependencies/_resolve',
+    ResolveDependenciesWithManifest: '/v2/apps/_resolve',
+    Settings: (app) => `${routes.App(app)}/settings`,
+    Unlink: (app) => `${routes.Links}/${app}`,
+};
+const contextQuery = (context) => context ? context.join('/') : context;
+const getVendorAndName = ({ id }) => id.split('@')[0];
+const notFound = (e) => {
+    if (e.response && e.response.status === 404) {
+        return {};
+    }
+    throw e;
+};
+const zipObj = (keys, values) => {
+    let idx = 0;
+    const len = Math.min(keys.length, values.length);
+    const out = {};
+    while (idx < len) {
+        out[keys[idx]] = values[idx];
+        idx += 1;
+    }
+    return out;
+};
+const paramsSerializer = (params) => {
+    return qs_1.stringify(params, { arrayFormat: 'repeat' });
+};
+class Apps extends IODataSource_1.IODataSource {
+    constructor() {
+        super(...arguments);
+        this.httpClientFactory = IODataSource_1.forWorkspace;
+        this.service = 'apps';
+        this.installApp = (descriptor) => {
+            return this.http.post(routes.Apps, { id: descriptor });
+        };
+        this.uninstallApp = (app) => {
+            return this.http.delete(routes.App(app));
+        };
+        this.acknowledgeApp = (app, service) => {
+            return this.http.put(routes.Acknowledge(app, service));
+        };
+        this.link = (app, files, { zlib } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (!(files[0] && files[0].path)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const emptyChanges = files.filter(file => !file.content);
+            if (emptyChanges.length > 0) {
+                throw new Error(`Missing content for paths: ${emptyChanges.map(e => e.path).join('; ')}`);
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = archiver('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const request = this.http.put(routes.Link(app), zip, {
+                headers: { 'Content-Type': 'application/zip' },
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            try {
+                const [response] = yield Promise.all([request, finalize]);
+                response.bundleSize = zip.pointer();
+                return response;
+            }
+            catch (e) {
+                e.bundleSize = zip.pointer();
+                throw e;
+            }
+        });
+        this.patch = (app, changes, { zlib } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (!(changes[0] && changes[0].path)) {
+                throw new Error('Argument changes must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const files = changes.filter(change => !!change.content);
+            const deletedFiles = changes
+                .filter(change => !change.content)
+                .map(change => change.path)
+                .join(':');
+            const zip = archiver('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const request = this.http.patch(routes.Link(app), zip, {
+                headers: { 'Content-Type': 'application/zip' },
+                params: { deletedFiles },
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            const [response] = yield Promise.all([request, finalize]);
+            return response;
+        });
+        this.unlink = (app) => {
+            return this.http.delete(routes.Unlink(app));
+        };
+        this.unlinkAll = () => {
+            return this.http.delete(routes.Links);
+        };
+        this.saveAppSettings = (app, settings) => {
+            const headers = { 'Content-Type': 'application/json' };
+            return this.http.put(routes.Settings(app), settings, { headers });
+        };
+        this.listApps = ({ oldVersion, context, since, service } = {}) => {
+            const params = {
+                context: contextQuery(context),
+                oldVersion,
+                service,
+                since,
+            };
+            return this.http.get(routes.Apps, { params });
+        };
+        this.listAppFiles = (app, { prefix, context, nextMarker } = {}) => {
+            const params = {
+                context: contextQuery(context),
+                marker: nextMarker,
+                prefix,
+            };
+            return this.http.get(routes.Files(app), { params });
+        };
+        this.listLinks = () => {
+            return this.http.get(routes.Links);
+        };
+        this.getAppFile = (app, path, context = []) => {
+            const params = { context: contextQuery(context) };
+            return this.http.getBuffer(routes.File(app, path), { params });
+        };
+        this.getAppFileStream = (app, path, context = []) => {
+            const params = { context: contextQuery(context) };
+            return this.http.getStream(routes.File(app, path), { params });
+        };
+        this.getApp = (app, context = []) => {
+            const params = { context: contextQuery(context) };
+            return this.http.get(routes.App(app), { params });
+        };
+        this.getAppSettings = (app) => {
+            return this.http.get(routes.Settings(app));
+        };
+        this.getAllAppsSettings = (listAppsOptions = {}) => {
+            return this.listApps(listAppsOptions).then(({ data: installedApps }) => {
+                const names = installedApps.map(getVendorAndName);
+                const settingsPromises = names.map(vendorAndName => this.getAppSettings(vendorAndName).catch(notFound));
+                return Promise.all(settingsPromises).then((settings) => {
+                    return zipObj(names, settings);
+                });
+            });
+        };
+        this.getAppBundle = (app, bundlePath, generatePackageJson) => {
+            const params = generatePackageJson && { _packageJSONEngine: 'npm', _packageJSONFilter: 'vtex.render-builder@x' };
+            return this.http.getStream(routes.AppBundle(app, bundlePath), {
+                headers: {
+                    Accept: 'application/x-gzip',
+                    'Accept-Encoding': 'gzip',
+                },
+                params,
+            });
+        };
+        this.unpackAppBundle = (app, bundlePath, unpackPath, generatePackageJson) => {
+            return this.getAppBundle(app, bundlePath, generatePackageJson)
+                .then(stream => stream
+                .pipe(zlib_1.createGunzip())
+                .pipe(tar_fs_1.extract(unpackPath)));
+        };
+        this.getDependencies = (filter = '') => {
+            const params = { filter };
+            return this.http.get(routes.Dependencies, { params });
+        };
+        this.updateDependencies = () => {
+            return this.http.put(routes.Dependencies);
+        };
+        this.updateDependency = (name, version, registry) => {
+            return this.http.patch(routes.Apps, [{ name, version, registry }]);
+        };
+        this.resolveDependencies = (apps, registries, filter = '') => {
+            const params = { apps, registries, filter };
+            return this.http.get(routes.ResolveDependencies, { params, paramsSerializer });
+        };
+        this.resolveDependenciesWithManifest = (manifest, filter = '') => {
+            const params = { filter };
+            return this.http.post(routes.ResolveDependenciesWithManifest, manifest, { params, paramsSerializer });
+        };
+    }
+}
+exports.Apps = Apps;

package/lib/Billing.d.ts

@@ -0,0 +1,18 @@
+import { IODataSource } from './IODataSource';
+export declare class Billing extends IODataSource {
+    protected service: string;
+    protected httpClientFactory: import("./IODataSource").HttpClientFactory;
+    contractStatus: () => Promise<ContractStatus>;
+    sendMetric: (metric: BillingMetric) => Promise<void>;
+}
+export declare enum ContractStatus {
+    ACTIVE = "active_contract",
+    INACTIVE = "inactive_contract",
+    NO_CONTRACT = "no_contract"
+}
+export interface BillingMetric {
+    value: number;
+    unit: string;
+    metricId: string;
+    timestamp?: number;
+}

package/lib/Billing.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const IODataSource_1 = require("./IODataSource");
+const metricRoute = `/metrics`;
+const routes = {
+    contractStatus: '/_v/contractStatus',
+};
+class Billing extends IODataSource_1.IODataSource {
+    constructor() {
+        super(...arguments);
+        this.service = 'billing.vtex';
+        this.httpClientFactory = IODataSource_1.forWorkspace;
+        this.contractStatus = () => {
+            return this.http.get(routes.contractStatus);
+        };
+        this.sendMetric = (metric) => {
+            return this.http.post(metricRoute, metric);
+        };
+    }
+}
+exports.Billing = Billing;
+var ContractStatus;
+(function (ContractStatus) {
+    ContractStatus["ACTIVE"] = "active_contract";
+    ContractStatus["INACTIVE"] = "inactive_contract";
+    ContractStatus["NO_CONTRACT"] = "no_contract";
+})(ContractStatus = exports.ContractStatus || (exports.ContractStatus = {}));

package/lib/Builder.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+import { ZlibOptions } from 'zlib';
+import { Change } from './Apps';
+import { InstanceOptions, IOContext } from './HttpClient';
+import { File } from './Registry';
+export declare class Builder {
+    private account;
+    private workspace;
+    private http;
+    private stickyHost;
+    constructor(ioContext: IOContext, opts?: InstanceOptions);
+    availability: (app: string, hintIndex: number) => Promise<{
+        host: any;
+        hostname: string | undefined;
+        score: number;
+    }>;
+    clean: (app: string) => Promise<BuildResult>;
+    linkApp: (app: string, files: File[], zipOptions?: ZipOptions) => Promise<BuildResult>;
+    publishApp: (app: string, files: File[], zipOptions?: ZipOptions) => Promise<BuildResult>;
+    relinkApp: (app: string, changes: Change[]) => Promise<BuildResult>;
+    private zipAndSend;
+}
+interface ZipOptions {
+    sticky?: boolean;
+    stickyHint?: string;
+    tag?: string;
+    zlib?: ZlibOptions;
+}
+export interface BuildResult {
+    availability?: AvailabilityResponse;
+    code?: string;
+    message?: any;
+    timeNano?: number;
+}
+export interface AvailabilityResponse {
+    host: string | undefined;
+    hostname: string | undefined;
+    score: number;
+}
+export {};

package/lib/Builder.js

@@ -0,0 +1,80 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    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) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const archiver = require("archiver");
+const HttpClient_1 = require("./HttpClient");
+const EMPTY_OBJECT = {};
+const routes = {
+    Availability: (app) => `${routes.Builder}/availability/${app}`,
+    Builder: '/_v/builder/0',
+    Clean: (app) => `${routes.Builder}/clean/${app}`,
+    Link: (app) => `${routes.Builder}/link/${app}`,
+    Publish: (app) => `${routes.Builder}/publish/${app}`,
+    Relink: (app) => `${routes.Builder}/relink/${app}`,
+};
+class Builder {
+    constructor(ioContext, opts = {}) {
+        this.availability = (app, hintIndex) => __awaiter(this, void 0, void 0, function* () {
+            const stickyHint = hintIndex === undefined || hintIndex === null ?
+                `request:${this.account}:${this.workspace}:${app}` :
+                `request:${this.account}:${this.workspace}:${app}:${hintIndex}`;
+            const headers = {
+                'Content-Type': 'application/json',
+                'x-vtex-sticky-host': stickyHint,
+            };
+            const { data: { availability }, headers: { 'x-vtex-sticky-host': host }, } = yield this.http.getRaw(routes.Availability(app), { headers });
+            const { hostname, score } = availability;
+            return { host, hostname, score };
+        });
+        this.clean = (app) => {
+            const headers = Object.assign({ 'Content-Type': 'application/json' }, this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost });
+            return this.http.post(routes.Clean(app), { headers });
+        };
+        this.linkApp = (app, files, zipOptions = { sticky: true }) => {
+            return this.zipAndSend(routes.Link(app), app, files, zipOptions);
+        };
+        this.publishApp = (app, files, zipOptions = { sticky: true }) => {
+            return this.zipAndSend(routes.Publish(app), app, files, zipOptions);
+        };
+        this.relinkApp = (app, changes) => {
+            const headers = Object.assign({ 'Content-Type': 'application/json' }, this.stickyHost && { 'x-vtex-sticky-host': this.stickyHost });
+            return this.http.put(routes.Relink(app), changes, { headers });
+        };
+        this.zipAndSend = (route, app, files, { tag, sticky, stickyHint, zlib } = {}) => __awaiter(this, void 0, void 0, function* () {
+            if (!(files[0] && files[0].path && files[0].content)) {
+                throw new Error('Argument files must be an array of {path, content}, where content can be a String, a Buffer or a ReadableStream.');
+            }
+            const indexOfManifest = files.findIndex(({ path }) => path === 'manifest.json');
+            if (indexOfManifest === -1) {
+                throw new Error('No manifest.json file found in files.');
+            }
+            const zip = archiver('zip', { zlib });
+            // Throw stream errors so they reject the promise chain.
+            zip.on('error', (e) => {
+                throw e;
+            });
+            const hint = stickyHint || `request:${this.account}:${this.workspace}:${app}`;
+            const request = this.http.postRaw(route, zip, {
+                headers: Object.assign({ 'Content-Type': 'application/octet-stream' }, sticky && { 'x-vtex-sticky-host': this.stickyHost || hint }),
+                params: tag ? { tag } : EMPTY_OBJECT,
+            });
+            files.forEach(({ content, path }) => zip.append(content, { name: path }));
+            const finalize = zip.finalize();
+            const [response] = yield Promise.all([request, finalize]);
+            const { data, headers: { 'x-vtex-sticky-host': host } } = response;
+            this.stickyHost = host;
+            return data;
+        });
+        this.http = HttpClient_1.HttpClient.forWorkspace('builder-hub.vtex', ioContext, opts);
+        this.account = ioContext.account;
+        this.workspace = ioContext.workspace;
+    }
+}
+exports.Builder = Builder;

package/lib/Events.d.ts

@@ -0,0 +1,6 @@
+import { HttpClientFactory, IODataSource } from './IODataSource';
+export declare class Events extends IODataSource {
+    protected service: string;
+    protected httpClientFactory: HttpClientFactory;
+    sendEvent: (subject: string, route: string, message?: any) => Promise<void>;
+}

package/lib/Events.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HttpClient_1 = require("./HttpClient");
+const IODataSource_1 = require("./IODataSource");
+const eventRoute = (route) => `/events/${route}`;
+const forWorkspaceWithoutRecorder = ({ service, context, options }) => (service && context)
+    ? HttpClient_1.HttpClient.forWorkspace(service, HttpClient_1.withoutRecorder(context), options || {})
+    : undefined;
+class Events extends IODataSource_1.IODataSource {
+    constructor() {
+        super(...arguments);
+        this.service = 'colossus';
+        this.httpClientFactory = forWorkspaceWithoutRecorder;
+        this.sendEvent = (subject, route, message) => {
+            return this.http.put(eventRoute(route), message, { params: { subject } });
+        };
+    }
+}
+exports.Events = Events;

package/lib/HttpClient/context.d.ts

@@ -0,0 +1,9 @@
+import { AxiosRequestConfig, AxiosResponse } from 'axios';
+export interface RequestConfig extends AxiosRequestConfig {
+    metric?: string;
+    production?: boolean;
+}
+export interface MiddlewareContext {
+    config: RequestConfig;
+    response?: AxiosResponse;
+}

package/lib/HttpClient/context.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/HttpClient/index.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="node" />
+import { DataSource } from 'apollo-datasource';
+import { IncomingMessage } from 'http';
+import { Context } from 'koa';
+import { ParsedUrlQuery } from 'querystring';
+import { CacheLayer } from '../caches/CacheLayer';
+import { MetricsAccumulator } from '../metrics/metricsAccumulator';
+import { MetricsLogger } from '../metrics/metricsLogger';
+import { RequestConfig } from './context';
+import { Cached } from './middlewares/cache';
+import { Recorder } from './middlewares/recorder';
+export declare class HttpClient {
+    static forWorkspace(service: string, context: IOContext, opts: InstanceOptions): HttpClient;
+    static forRoot(service: string, context: IOContext, opts: InstanceOptions): HttpClient;
+    static forLegacy(endpoint: string, opts: LegacyInstanceOptions): HttpClient;
+    private runMiddlewares;
+    constructor(opts: ClientOptions);
+    get: <T = any>(url: string, config?: RequestConfig) => Promise<T>;
+    getRaw: <T = any>(url: string, config?: RequestConfig) => Promise<IOResponse<T>>;
+    getBuffer: (url: string, config?: RequestConfig) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getStream: (url: string, config?: RequestConfig) => Promise<IncomingMessage>;
+    put: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    post: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    postRaw: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<IOResponse<T>>;
+    patch: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    delete: (url: string, config?: RequestConfig | undefined) => Promise<IOResponse<void>>;
+    private request;
+}
+export declare const withoutRecorder: (ioContext: IOContext) => IOContext;
+export declare type CacheStorage = CacheLayer<string, Cached>;
+export declare type Recorder = Recorder;
+export interface DataSources {
+    [name: string]: DataSource<ServiceContext>;
+}
+export interface ServiceContext extends Context {
+    vtex: IOContext;
+    dataSources?: DataSources;
+    metricsLogger?: MetricsLogger;
+}
+export interface IOContext {
+    account: string;
+    authToken: string;
+    production: boolean;
+    recorder?: Recorder;
+    region: string;
+    route: {
+        declarer?: string;
+        id: string;
+        params: ParsedUrlQuery;
+    };
+    userAgent: string;
+    workspace: string;
+    segmentToken?: string;
+    sessionToken?: string;
+}
+export interface InstanceOptions {
+    timeout?: number;
+    cacheStorage?: CacheLayer<string, Cached>;
+    endpoint?: string;
+}
+export interface LegacyInstanceOptions {
+    authToken: string;
+    userAgent: string;
+    timeout?: number;
+    accept?: string;
+    cacheStorage?: CacheLayer<string, Cached>;
+}
+export interface IOResponse<T> {
+    data: T;
+    headers: any;
+    status: number;
+}
+declare enum AuthType {
+    bearer = "bearer",
+    token = "token"
+}
+interface ClientOptions {
+    authType?: AuthType;
+    authToken?: string;
+    userAgent: string;
+    baseURL?: string;
+    timeout?: number;
+    recorder?: Recorder;
+    metrics?: MetricsAccumulator;
+    cacheStorage?: CacheLayer<string, Cached>;
+    segmentToken?: string;
+    sessionToken?: string;
+}
+export {};