@ui5/task-adaptation 1.3.1 → 1.3.2

package/dist/processors/abapProcessor.js

@@ -0,0 +1,37 @@
+import { validateObject } from "../util/commonUtil.js";
+import Language from "../model/language.js";
+export default class AbapProcessor {
+    abapRepoManager;
+    configuration;
+    cacheManager;
+    annotationManager;
+    constructor(configuration, cacheManager, abapRepoManager, annotationManager) {
+        this.configuration = configuration;
+        this.abapRepoManager = abapRepoManager;
+        this.cacheManager = cacheManager;
+        this.annotationManager = annotationManager;
+    }
+    getBaseAppFiles(baseAppId) {
+        return this.cacheManager.getFiles(() => this.abapRepoManager.getMetadata(baseAppId), () => this.abapRepoManager.downloadBaseAppFiles());
+    }
+    validateConfiguration() {
+        validateObject(this.configuration, ["destination", "appName"], "should be specified in ui5.yaml configuration");
+    }
+    async updateLandscapeSpecificContent(renamedBaseAppManifest, baseAppFiles) {
+        const files = await this.annotationManager.process(renamedBaseAppManifest, (Language.create(this.configuration.languages)));
+        if (baseAppFiles) {
+            files.forEach((value, key) => baseAppFiles.set(key, value));
+        }
+    }
+    getConfigurationType() {
+        return "abap";
+    }
+    createAppVariantHierarchyItem(appVariantId, version) {
+        return {
+            appVariantId,
+            version,
+            layer: "VENDOR"
+        };
+    }
+}
+//# sourceMappingURL=abapProcessor.js.map

package/dist/processors/cfProcessor.d.ts

@@ -0,0 +1,17 @@
+import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
+import { IConfiguration } from "../model/types.js";
+import IProcessor from "./processor.js";
+export default class CFProcessor implements IProcessor {
+    private configuration;
+    private cacheManager;
+    constructor(configuration: IConfiguration, cacheManager: BaseAppFilesCacheManager);
+    getBaseAppFiles(): Promise<Map<string, string>>;
+    validateConfiguration(): void;
+    updateLandscapeSpecificContent(renamedBaseAppManifest: any): Promise<void>;
+    private updateCloudPlatform;
+    getConfigurationType(): string;
+    createAppVariantHierarchyItem(appVariantId: string, version: string): {
+        appVariantId: string;
+        version: string;
+    };
+}

package/dist/processors/cfProcessor.js

@@ -0,0 +1,45 @@
+import HTML5RepoManager from "../repositories/html5RepoManager.js";
+import { validateObject } from "../util/commonUtil.js";
+export default class CFProcessor {
+    configuration;
+    cacheManager;
+    constructor(configuration, cacheManager) {
+        this.configuration = configuration;
+        this.cacheManager = cacheManager;
+    }
+    async getBaseAppFiles() {
+        return this.cacheManager.getFiles(() => HTML5RepoManager.getMetadata(this.configuration), () => HTML5RepoManager.getBaseAppFiles(this.configuration));
+    }
+    validateConfiguration() {
+        validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
+    }
+    async updateLandscapeSpecificContent(renamedBaseAppManifest) {
+        this.updateCloudPlatform(renamedBaseAppManifest);
+    }
+    updateCloudPlatform(renamedBaseAppManifest) {
+        const sapCloudService = renamedBaseAppManifest["sap.cloud"]?.service;
+        const sapPlatformCf = renamedBaseAppManifest["sap.platform.cf"];
+        if (sapPlatformCf && sapCloudService) {
+            sapPlatformCf.oAuthScopes = sapPlatformCf.oAuthScopes.map((scope) => scope.replace(`$XSAPPNAME.`, `$XSAPPNAME('${sapCloudService}').`));
+        }
+        if (this.configuration.sapCloudService) {
+            if (renamedBaseAppManifest["sap.cloud"] == null) {
+                renamedBaseAppManifest["sap.cloud"] = {};
+            }
+            renamedBaseAppManifest["sap.cloud"].service = this.configuration.sapCloudService;
+        }
+        else {
+            delete renamedBaseAppManifest["sap.cloud"];
+        }
+    }
+    getConfigurationType() {
+        return "cf";
+    }
+    createAppVariantHierarchyItem(appVariantId, version) {
+        return {
+            appVariantId,
+            version
+        };
+    }
+}
+//# sourceMappingURL=cfProcessor.js.map

package/dist/processors/processor.d.ts

@@ -0,0 +1,7 @@
+import { IConfiguration } from "../model/types.js";
+export default interface IProcessor {
+    createAppVariantHierarchyItem(appVariantId: string, version: string): void;
+    getBaseAppFiles(baseAppId: string): Promise<Map<string, string>>;
+    updateLandscapeSpecificContent(renamedBaseAppManifest: any, baseAppFiles?: Map<string, string>): Promise<void>;
+}
+export declare function determineProcessor(configuration: IConfiguration): IProcessor;

package/dist/processors/processor.js

@@ -0,0 +1,32 @@
+import AbapProcessor from "./abapProcessor.js";
+import AbapRepoManager from "../repositories/abapRepoManager.js";
+import AnnotationManager from "../annotationManager.js";
+import BaseAppFilesCacheManager from "../cache/baseAppFilesCacheManager.js";
+import CFProcessor from "./cfProcessor.js";
+export function determineProcessor(configuration) {
+    const cacheManager = new BaseAppFilesCacheManager(configuration);
+    const abapRepoManager = new AbapRepoManager(configuration);
+    const annotationManager = new AnnotationManager(configuration, abapRepoManager);
+    const processors = [
+        new CFProcessor(configuration, cacheManager),
+        new AbapProcessor(configuration, cacheManager, abapRepoManager, annotationManager)
+    ];
+    let processor = processors.find(processor => processor.getConfigurationType() === configuration.type);
+    if (processor) {
+        processor.validateConfiguration();
+        return processor;
+    }
+    else {
+        for (const processor of processors) {
+            try {
+                processor.validateConfiguration();
+                return processor;
+            }
+            catch (error) {
+                continue;
+            }
+        }
+    }
+    throw new Error("ui5.yaml configuration should correspond either ABAP or SAP BTP landscape");
+}
+//# sourceMappingURL=processor.js.map

package/dist/repositories/abapRepoManager.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration, IMetadata } from "../model/types.js";
+export default class AbapRepoManager {
+    private auth?;
+    private configuration;
+    constructor(configuration: IConfiguration);
+    getAnnotationMetadata(uri: string): Promise<IMetadata>;
+    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    getMetadata(baseAppId: string): Promise<IMetadata>;
+    downloadBaseAppFiles(): Promise<Map<string, string>>;
+    private getMetadataRequest;
+    private downloadBaseAppFilesRequest;
+    private getAuth;
+}

package/dist/repositories/abapRepoManager.js

@@ -0,0 +1,82 @@
+import RequestUtil from "../util/requestUtil.js";
+import { getLogger } from "@ui5/logger";
+import { unzipZipEntries } from "../util/zipUtil.js";
+const log = getLogger("@ui5/task-adaptation::AbapRepoManager");
+const REQUEST_OPTIONS_XML = {
+    responseType: "text",
+    headers: {
+        "Accept": "text/html,application/xhtml+xml,application/xml"
+    }
+};
+const REQUEST_OPTIONS_JSON = {
+    headers: {
+        "Accept": "application/json"
+    }
+};
+export default class AbapRepoManager {
+    auth;
+    configuration;
+    constructor(configuration) {
+        this.configuration = configuration;
+    }
+    async getAnnotationMetadata(uri) {
+        const header = await RequestUtil.retryWithAuth(() => RequestUtil.head(uri), () => RequestUtil.head(uri, this.getAuth()));
+        return { changedOn: header.modified };
+    }
+    async downloadAnnotationFile(uri) {
+        const annotationUri = `https://${this.configuration.destination}.dest${uri}`;
+        const annotation = await RequestUtil.retryWithAuth(() => RequestUtil.get(annotationUri, REQUEST_OPTIONS_XML), () => RequestUtil.get(annotationUri, REQUEST_OPTIONS_XML, this.getAuth()));
+        return new Map([["annotation.xml", annotation]]);
+    }
+    getMetadata(baseAppId) {
+        return RequestUtil.retryWithAuth(() => this.getMetadataRequest(baseAppId), () => this.getMetadataRequest(baseAppId, this.getAuth()));
+    }
+    downloadBaseAppFiles() {
+        return RequestUtil.retryWithAuth(() => this.downloadBaseAppFilesRequest(), () => this.downloadBaseAppFilesRequest(this.getAuth()));
+    }
+    async getMetadataRequest(id, auth) {
+        let uri = `https://${this.configuration.destination}.dest/sap/bc/ui2/app_index/ui5_app_info_json?id=${id}`;
+        const data = await RequestUtil.get(uri, REQUEST_OPTIONS_JSON, auth);
+        if (data && data[id]) {
+            return {
+                changedOn: data[id].url,
+                id
+            };
+        }
+        log.warn(`UI5AppInfoJson request doesn't contain cache buster token for sap.app/id '${id}'. Fallback to download.`);
+    }
+    async downloadBaseAppFilesRequest(auth) {
+        const { destination, appName } = this.configuration;
+        const encodedAppName = encodeURIComponent(appName);
+        const uri = `https://${destination}.dest/sap/opu/odata/UI5/ABAP_REPOSITORY_SRV/Repositories('${encodedAppName}')?DownloadFiles=RUNTIME&CodePage=UTF8`;
+        const data = await RequestUtil.get(uri, {}, auth);
+        if (data?.d?.ZipArchive.length > 0) {
+            const buffer = Buffer.from(data.d.ZipArchive, "base64");
+            return unzipZipEntries(buffer);
+        }
+        throw new Error(`App '${appName}' from destination '${destination}' doesn't contain files`);
+    }
+    getAuth() {
+        if (!this.auth) {
+            if (this.configuration?.credentials) {
+                let { username, password } = this.configuration?.credentials;
+                if (username && password) {
+                    const ENV_PREFIX = "env:";
+                    username = username.substring(ENV_PREFIX.length);
+                    password = password.substring(ENV_PREFIX.length);
+                    if (process.env[username] && process.env[password]) {
+                        this.auth = {
+                            username: process.env[username],
+                            password: process.env[password]
+                        };
+                    }
+                }
+            }
+        }
+        if (!this.auth) {
+            throw new Error("Please provide ABAP System credentials in .env file of the project: https://help.sap.com/docs/SAP_FIORI_tools/17d50220bcd848aa854c9c182d65b699/1c859274b511435ab6bd45f70e7f9af2.html.");
+        }
+        return this.auth;
+    }
+}
+//# sourceMappingURL=abapRepoManager.js.map

package/dist/repositories/html5RepoManager.d.ts

@@ -0,0 +1,11 @@
+import { IConfiguration } from "./../model/types.js";
+export default class HTML5RepoManager {
+    static getBaseAppFiles(configuration: IConfiguration): Promise<Map<string, string>>;
+    static getMetadata(configuration: IConfiguration): Promise<any>;
+    private static getHtml5RepoInfo;
+    private static getHTML5Credentials;
+    private static getToken;
+    private static requestMetadata;
+    private static getBaseAppZipEntries;
+    private static download;
+}

package/dist/repositories/html5RepoManager.js

@@ -0,0 +1,87 @@
+import CFUtil from "./../util/cfUtil.js";
+import RequestUtil from "./../util/requestUtil.js";
+import { getLogger } from "@ui5/logger";
+import { unzipZipEntries } from "./../util/zipUtil.js";
+const log = getLogger("@ui5/task-adaptation::HTML5RepoManager");
+export default class HTML5RepoManager {
+    static async getBaseAppFiles(configuration) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        return this.getBaseAppZipEntries(configuration, baseUri, token);
+    }
+    static async getMetadata(configuration) {
+        const { token, baseUri } = await this.getHtml5RepoInfo(configuration);
+        return this.requestMetadata(configuration, baseUri, token);
+    }
+    static async getHtml5RepoInfo(configuration) {
+        const spaceGuid = await CFUtil.getSpaceGuid(configuration?.spaceGuid);
+        const credentials = await this.getHTML5Credentials(spaceGuid);
+        const token = await this.getToken(credentials);
+        return {
+            token,
+            baseUri: credentials.uri
+        };
+    }
+    static async getHTML5Credentials(spaceGuid) {
+        log.verbose("Getting HTML5 Repo Runtime credentials from space " + spaceGuid);
+        const PLAN_NAME = "app-runtime";
+        const SERVIСE_INSTANCE_NAME = "html5-apps-repo-runtime";
+        const getParams = {
+            spaceGuids: [spaceGuid],
+            planNames: [PLAN_NAME],
+            names: [SERVIСE_INSTANCE_NAME]
+        };
+        const createParams = {
+            spaceGuid,
+            planName: PLAN_NAME,
+            serviceName: SERVIСE_INSTANCE_NAME,
+            tags: ["html5-apps-repo-rt"]
+        };
+        const serviceKeys = await CFUtil.getServiceInstanceKeys(getParams, createParams);
+        return serviceKeys.credentials;
+    }
+    static async getToken({ uaa }) {
+        log.verbose("Getting HTML5 Repo token");
+        const auth = Buffer.from(uaa.clientid + ":" + uaa.clientsecret);
+        const options = {
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Basic " + auth.toString("base64")
+            }
+        };
+        const uri = `${uaa.url}/oauth/token?grant_type=client_credentials`;
+        return RequestUtil.get(uri, options).then((json) => json["access_token"]);
+    }
+    static async requestMetadata(options, html5RepoBaseUri, token) {
+        const { appHostId, appName, appVersion } = options;
+        const uri = `${html5RepoBaseUri}/applications/metadata/`;
+        const requestOptions = {
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer " + token,
+                "x-app-host-id": appHostId
+            }
+        };
+        const metadata = await RequestUtil.get(uri, requestOptions);
+        return metadata.find((item) => item.appHostId === appHostId && item.applicationName === appName && item.applicationVersion === appVersion);
+    }
+    static async getBaseAppZipEntries(options, html5RepoBaseUri, token) {
+        const { appHostId, appName, appVersion } = options;
+        const uri = `${html5RepoBaseUri}/applications/content/${appName}-${appVersion}/`;
+        const zip = await this.download(token, appHostId, uri);
+        return unzipZipEntries(zip);
+    }
+    static async download(token, appHostId, uri) {
+        if (!token) {
+            throw new Error("HTML5 token is undefined");
+        }
+        return RequestUtil.get(uri, {
+            responseType: "arraybuffer",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": "Bearer " + token,
+                "x-app-host-id": appHostId
+            }
+        });
+    }
+}
+//# sourceMappingURL=html5RepoManager.js.map

package/dist/util/cfUtil.d.ts

@@ -0,0 +1,30 @@
+import { ICreateServiceInstanceParams, IGetServiceInstanceParams, IResource, IServiceKeys } from "../model/types.js";
+export default class CFUtil {
+    /**
+     * Get or create service keys for service instance found by query
+     * @static
+     * @param {IGetServiceInstanceParams} getServiceInstanceParams query parameters to find a service instance by
+     * @param {ICreateServiceInstanceParams} [createServiceInstanceParams] parameters to create a service instance
+     * @return {Promise<IServiceKeys>} promise with service keys
+     * @memberof CFUtil
+     */
+    static getServiceInstanceKeys(getServiceInstanceParams: IGetServiceInstanceParams, createServiceInstanceParams?: ICreateServiceInstanceParams): Promise<IServiceKeys>;
+    static createService(params: ICreateServiceInstanceParams): Promise<void>;
+    private static getOrCreateServiceKeys;
+    private static getServiceKeys;
+    private static createServiceKey;
+    private static getServiceInstance;
+    static requestCfApi(url: string): Promise<IResource[]>;
+    static getOAuthToken(): Promise<string>;
+    private static cfExecute;
+    private static errorsToString;
+    private static parseJson;
+    /**
+     * Get space guid from configuration or local CF fodler
+     * @static
+     * @param {string} spaceGuid ui5.yaml options
+     * @return {Promise<string>} promise with space guid
+     * @memberof CFUtil
+     */
+    static getSpaceGuid(spaceGuid?: string): Promise<string>;
+}

package/dist/util/cfUtil.js

@@ -0,0 +1,171 @@
+import { cfCreateService, cfGetInstanceCredentials, cfGetTarget } from "@sap/cf-tools/out/src/cf-local.js";
+import { Cli } from "@sap/cf-tools/out/src/cli.js";
+import { eFilters } from "@sap/cf-tools/out/src/types.js";
+import { getLogger } from "@ui5/logger";
+const log = getLogger("@ui5/task-adaptation::CFUtil");
+export default class CFUtil {
+    /**
+     * Get or create service keys for service instance found by query
+     * @static
+     * @param {IGetServiceInstanceParams} getServiceInstanceParams query parameters to find a service instance by
+     * @param {ICreateServiceInstanceParams} [createServiceInstanceParams] parameters to create a service instance
+     * @return {Promise<IServiceKeys>} promise with service keys
+     * @memberof CFUtil
+     */
+    static async getServiceInstanceKeys(getServiceInstanceParams, createServiceInstanceParams) {
+        let serviceInstances = await this.getServiceInstance(getServiceInstanceParams);
+        if (!(serviceInstances?.length > 0) && createServiceInstanceParams) {
+            await this.createService(createServiceInstanceParams);
+            serviceInstances = await this.getServiceInstance(getServiceInstanceParams);
+        }
+        if (!(serviceInstances?.length > 0)) {
+            throw new Error(`Cannot find '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
+        }
+        // we can use any instance in the list to connect to HTML5 Repo
+        log.verbose(`Use '${serviceInstances[0].name}' HTML5 Repo Runtime service instance`);
+        const serviceKeys = await this.getOrCreateServiceKeys(serviceInstances[0]);
+        if (!(serviceKeys?.length > 0)) {
+            throw new Error(`Cannot get service keys for '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
+        }
+        return {
+            credentials: serviceKeys[0].credentials,
+            serviceInstance: serviceInstances[0]
+        };
+    }
+    static async createService(params) {
+        log.verbose(`Creating a service instance with parameters: ${JSON.stringify(params)}`);
+        const resources = await this.requestCfApi(`/v3/service_plans?names=${params.planName}&space_guids=${params.spaceGuid}`);
+        const publicPlan = resources.find(resource => resource.visibility_type === "public");
+        if (!publicPlan) {
+            throw new Error(`Cannot find a public plan by name '${params.serviceName}' in space '${params.spaceGuid}'`);
+        }
+        try {
+            await cfCreateService(publicPlan.guid, params.serviceName, params.parameters, params.tags);
+        }
+        catch (error) {
+            throw new Error(`Cannot create a service instance '${params.serviceName}' in space '${params.spaceGuid}': ${error.message}`);
+        }
+    }
+    static async getOrCreateServiceKeys(serviceInstance) {
+        const credentials = await this.getServiceKeys(serviceInstance.guid);
+        if (credentials.length === 0) {
+            const serviceKeyName = serviceInstance.name + "_key";
+            log.info(`Creating service key '${serviceKeyName}' for service instance '${serviceInstance.name}'`);
+            await this.createServiceKey(serviceInstance.name, serviceKeyName);
+        }
+        else {
+            return credentials;
+        }
+        return this.getServiceKeys(serviceInstance.guid);
+    }
+    static getServiceKeys(serviceInstanceGuid) {
+        return cfGetInstanceCredentials({
+            filters: [{
+                    value: serviceInstanceGuid,
+                    key: eFilters.service_instance_guids
+                }]
+        }).catch((error) => {
+            throw new Error("Failed to get service credentials: " + error.message);
+        });
+    }
+    static async createServiceKey(serviceInstanceName, serviceKeyName) {
+        try {
+            return this.cfExecute(["create-service-key", serviceInstanceName, serviceKeyName]);
+        }
+        catch (error) {
+            throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}`);
+        }
+    }
+    static async getServiceInstance(params) {
+        const PARAM_MAP = {
+            spaceGuids: "space_guids",
+            planNames: "service_plan_names",
+            names: "names"
+        };
+        const parameters = Object.entries(params)
+            .filter(([, value]) => value?.length && value?.length > 0)
+            .map(([key, value]) => `${PARAM_MAP[key]}=${value?.join(",")}`);
+        const uri = `/v3/service_instances` + (parameters.length > 0 ? `?${parameters.join("&")}` : "");
+        const resources = await this.requestCfApi(uri);
+        return resources.map((service) => ({
+            name: service.name,
+            guid: service.guid
+        }));
+    }
+    static async requestCfApi(url) {
+        const response = await this.cfExecute(["curl", url]);
+        const json = this.parseJson(response);
+        const resources = json?.resources;
+        const totalPages = json?.pagination?.total_pages;
+        if (totalPages > 1) {
+            const pages = Array.from({ length: totalPages - 1 }, (_, i) => i + 2);
+            return resources.concat(await Promise.all(pages.map(async (page) => {
+                const uri = `${url}${url.includes("?") ? "&" : "?"}page=${page}`;
+                const response = await this.cfExecute(["curl", uri]);
+                return this.parseJson(response)?.resources || [];
+            })).then(resources => [].concat(...resources)));
+        }
+        return resources;
+    }
+    static getOAuthToken() {
+        return this.cfExecute(["oauth-token"]);
+    }
+    static async cfExecute(params) {
+        const MAX_ATTEMPTS = 3;
+        const errors = new Set();
+        for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+            try {
+                const response = await Cli.execute(params, { env: { "CF_COLOR": "false" } });
+                if (response.exitCode === 0) {
+                    const errorValues = [...errors.values()];
+                    if (errorValues?.length > 0) {
+                        log.verbose(this.errorsToString(errorValues));
+                    }
+                    return response.stdout;
+                }
+                errors.add(response.error || response.stderr);
+            }
+            catch (error) {
+                errors.add(error.message);
+            }
+        }
+        throw new Error(`Failed to send request with parameters '${JSON.stringify(params)}': ${this.errorsToString([...errors.values()])}`);
+    }
+    static errorsToString(errors) {
+        return errors.length > 1
+            ? errors.map((error, attempt) => `${attempt + 1} attempt: ${error}`).join("; ")
+            : errors.map(error => error);
+    }
+    static parseJson(jsonString) {
+        try {
+            return JSON.parse(jsonString);
+        }
+        catch (error) {
+            throw new Error(`Failed parse response from request CF API: ${error.message}`);
+        }
+    }
+    /**
+     * Get space guid from configuration or local CF fodler
+     * @static
+     * @param {string} spaceGuid ui5.yaml options
+     * @return {Promise<string>} promise with space guid
+     * @memberof CFUtil
+     */
+    static async getSpaceGuid(spaceGuid) {
+        if (spaceGuid == null) {
+            const spaceName = (await cfGetTarget())?.space;
+            if (spaceName) {
+                const resources = await this.requestCfApi(`/v3/spaces?names=${spaceName}`);
+                for (const resource of resources) {
+                    spaceGuid = resource.guid;
+                    break;
+                }
+            }
+        }
+        if (spaceGuid == null) {
+            throw new Error("Please login to Cloud Foundry with 'cf login' and try again");
+        }
+        return spaceGuid;
+    }
+}
+//# sourceMappingURL=cfUtil.js.map

package/dist/util/commonUtil.d.ts

@@ -0,0 +1,13 @@
+import { IConfiguration } from "../model/types.js";
+import Language from "../model/language.js";
+export declare function dotToUnderscore(value: string): string;
+export declare function validateObject<T extends Object>(options: T, properties: Array<keyof T>, message: string): void;
+export declare function escapeRegex(update: string): string;
+export declare function renameResources(files: Map<string, string>, search: string, replacement: string): Map<string, string>;
+export declare function insertInArray<T>(array: T[], index: number, insert: T): void;
+export declare function writeTempAnnotations({ writeTempFiles }: IConfiguration, name: string, language: Language, content: string): void;
+export declare function removePropertiesExtension(filePath: string): string;
+export declare function traverse(json: any, paths: string[], callback: (json: any, key: string | number, paths: string[]) => void): void;
+export declare function logBuilderVersion(): void;
+export declare function logBetaUsage(): void;
+export declare function getUniqueName(existingNames: string[], template: string): string;