@ui5/task-adaptation 1.6.7 → 1.7.0

package/dist/landscapeConfiguration.js

@@ -8,12 +8,16 @@ const log = getLogger("@ui5/task-adaptation::LandscapeConfiguration");
 export async function initialize(configuration, options = {}) {
     const type = await getTypeByConfiguration(configuration);
     const enhancedConfig = { ...configuration, type };
-    const repository = await getRepository(enhancedConfig, options);
+    let repository = await getRepository(enhancedConfig);
     const annotationManager = await getAnnotationManager(enhancedConfig, repository);
+    if (options.useCache) {
+        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
+        repository = new CacheRepository(repository);
+    }
+    const adapter = await getAdapter(enhancedConfig, annotationManager);
     return {
-        adapter: await getAdapter(enhancedConfig, annotationManager),
-        repository,
-        annotationManager
+        adapter,
+        repository
     };
 }
 async function getTypeByConfiguration(configuration) {
@@ -38,62 +42,62 @@ async function getTypeByConfiguration(configuration) {
         throw new Error("'type' should be specified in ui5.yaml configuration: 'cf' or 'abap'");
     }
 }
-async function getAdapter(configuration, annotationManager) {
-    if (isPreview()) {
-        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
-        return new PreviewAdapter(configuration);
-    }
-    switch (configuration.type) {
-        case "abap": {
+const LANDSCAPE_FACTORIES = {
+    abap: {
+        adapter: async (_configuration, annotationManager) => {
             const { default: AbapAdapter } = await import("./adapters/abapAdapter.js");
             return new AbapAdapter(annotationManager);
-        }
-        case "cf": {
+        },
+        repository: async (configuration) => {
+            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
+            return new AbapRepository(configuration);
+        },
+        annotationManager: async (configuration, repository) => {
+            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
+            return new AbapAnnotationManager(configuration, repository);
+        },
+    },
+    cf: {
+        adapter: async (configuration) => {
             const { default: CFAdapter } = await import("./adapters/cfAdapter.js");
             return new CFAdapter(configuration);
-        }
-        default:
-            throw new Error(`No adapter found for the given configuration type '${configuration.type}'`);
+        },
+        repository: async (configuration) => {
+            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
+            return new HTML5Repository(configuration);
+        },
+        annotationManager: async () => {
+            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
+            return new CFAnnotationManager();
+        },
+    },
+};
+function landscapeFactory(configuration) {
+    const factory = LANDSCAPE_FACTORIES[configuration.type];
+    if (!factory) {
+        throw new Error(`No landscape factory found for the given configuration type '${configuration.type}'`);
     }
+    return factory;
 }
-async function getRepository(configuration, options) {
-    if (options.useCacheRepository) {
-        const { default: CacheRepository } = await import("./repositories/cacheRepository.js");
-        return new CacheRepository(configuration);
+async function getAdapter(configuration, annotationManager) {
+    if (isPreview()) {
+        const { default: PreviewAdapter } = await import("./adapters/previewAdapter.js");
+        return new PreviewAdapter(configuration);
     }
+    return landscapeFactory(configuration).adapter(configuration, annotationManager);
+}
+async function getRepository(configuration) {
     if (isLocal()) {
         const { default: LocalRepository } = await import("./repositories/localRepository.js");
         return new LocalRepository();
     }
-    switch (configuration.type) {
-        case "abap": {
-            const { default: AbapRepository } = await import("./repositories/abapRepository.js");
-            return new AbapRepository(configuration);
-        }
-        case "cf": {
-            const { default: HTML5Repository } = await import("./repositories/html5Repository.js");
-            return new HTML5Repository(configuration);
-        }
-        default:
-            throw new Error(`No repository found for the given configuration type '${configuration.type}'`);
-    }
+    return landscapeFactory(configuration).repository(configuration);
 }
 async function getAnnotationManager(configuration, repository) {
     if (isLocal()) {
         return new LocalAnnotationManager();
     }
-    switch (configuration.type) {
-        case "abap": {
-            const { default: AbapAnnotationManager } = await import("./annotations/abapAnnotationManager.js");
-            return new AbapAnnotationManager(configuration, repository);
-        }
-        case "cf": {
-            const { default: CFAnnotationManager } = await import("./annotations/cfAnnotationManager.js");
-            return new CFAnnotationManager();
-        }
-        default:
-            throw new Error(`No annotation manager found for the given configuration type '${configuration.type}'`);
-    }
+    return landscapeFactory(configuration).annotationManager(configuration, repository);
 }
 function isLocal() {
     return process.env.ADP_BUILDER_MODE === "local";

package/dist/model/configuration.d.ts

@@ -12,7 +12,6 @@ export interface IConfiguration {
     languages?: any[] | undefined;
     enableAnnotationCache?: boolean;
     enableBetaFeatures?: boolean;
-    writeTempFiles?: any;
     target?: AbapTarget & IAbapTargetMeta;
     serviceInstanceName?: string;
 }

package/dist/model/types.d.ts

@@ -22,6 +22,7 @@ export interface IGetServiceInstanceParams {
 export interface IServiceInstance {
     name: string;
     guid: string;
+    type?: string;
 }
 export interface IResource {
     name: string;
@@ -131,6 +132,3 @@ export type ServiceCredentials = {
 };
 export type FetchFilesPromise = Map<string, Promise<ReadonlyMap<string, Buffer>>>;
 export { IConfiguration };
-export interface IInitializeOptions {
-    useCacheRepository?: boolean;
-}

package/dist/repositories/abapRepository.d.ts

@@ -9,7 +9,7 @@ export default class AbapRepository implements IRepository {
     constructor(configuration: IConfiguration, abapProvider?: AbapProvider);
     getAppVariantIdHierarchy(id: string): Promise<IAbapResource[]>;
     getAnnotationMetadata(uri: string): Promise<IMetadata>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, any>>;
+    downloadAnnotationFile(uri: string): Promise<any>;
     getMetadata(id: string): Promise<IMetadata>;
     fetch(resource: IAbapResource): Promise<Map<string, Buffer>>;
 }

package/dist/repositories/abapRepository.js

@@ -37,14 +37,14 @@ export default class AbapRepository {
             const hierarchy = JSON.parse(response.data)?.appVariantIdHierarchy;
             return hierarchy.map(item => ({
                 appName: item.repoName,
-                cacheBusterToken: Promise.resolve(item.cachebusterToken)
+                token: Promise.resolve(item.cachebusterToken)
             }));
         }
         else if (this.configuration.appName) {
             // Fallback to old API on old ABAP backend or CF for backward compatibility
             return [{
                     appName: this.configuration.appName,
-                    cacheBusterToken: this.getMetadata(id).then(metadata => metadata.changedOn),
+                    token: this.getMetadata(id).then(metadata => metadata.changedOn),
                 }];
         }
         throw new Error(`App variant id hierarchy for app id '${id}' is not provided`);
@@ -59,7 +59,7 @@ export default class AbapRepository {
         const response = await provider.get(uri, {
             headers: REQUEST_OPTIONS_XML.headers
         });
-        return new Map([["annotation.xml", response.data]]);
+        return response.data;
     }
     async getMetadata(id) {
         const provider = await this.abapProvider.get(this.configuration);

package/dist/repositories/cacheRepository.d.ts

@@ -1,10 +1,9 @@
 import ICachedResource from "../cache/cachedResource.js";
-import { IConfiguration } from "../model/types.js";
 import IRepository from "./repository.js";
 export default class CacheRepository implements IRepository {
-    private configuration;
-    constructor(configuration: IConfiguration);
-    getAppVariantIdHierarchy(_appId: string): Promise<ICachedResource[]>;
+    private repository;
+    constructor(repository: IRepository);
+    getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
     fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(uri: string): Promise<string>;
 }

package/dist/repositories/cacheRepository.js

@@ -1,29 +1,21 @@
 import CacheHolder from "../cache/cacheHolder.js";
 export default class CacheRepository {
-    configuration;
-    constructor(configuration) {
-        this.configuration = configuration;
+    repository;
+    constructor(repository) {
+        this.repository = repository;
     }
-    async getAppVariantIdHierarchy(_appId) {
-        const { appName } = this.configuration;
-        if (!appName) {
-            throw new Error("previewManifest requires 'appName' in the ui5.yaml configuration");
+    async getAppVariantIdHierarchy(appId) {
+        const mergedResource = CacheHolder.mergedResource(appId);
+        if (await CacheHolder.hasDirectory(mergedResource)) {
+            return [mergedResource];
         }
-        return [{
-                appName,
-                cacheBusterToken: Promise.resolve("")
-            }];
+        return this.repository.getAppVariantIdHierarchy(appId);
     }
     async fetch(resource) {
-        const appName = resource.appName;
-        const cachedFiles = await CacheHolder.readLatest(appName);
-        if (cachedFiles.size === 0) {
-            throw new Error(`No cached base app found for '${appName}'. Please check the appName or run a full build first to populate the cache.`);
-        }
-        return cachedFiles;
+        return this.repository.fetch(resource);
     }
     downloadAnnotationFile(uri) {
-        throw new Error(`Download annotation file for uri: ${uri} is not available for CacheRepository.`);
+        return this.repository.downloadAnnotationFile(uri);
     }
 }
 //# sourceMappingURL=cacheRepository.js.map

package/dist/repositories/html5Repository.d.ts

@@ -18,5 +18,5 @@ export default class HTML5Repository implements IRepository {
     private requestMetadata;
     private getAppZipEntries;
     private download;
-    downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(_uri: string): Promise<string>;
 }

package/dist/repositories/html5Repository.js

@@ -25,7 +25,7 @@ export default class HTML5Repository {
         }
         return [{
                 appName,
-                cacheBusterToken: this.getMetadata().then(metadata => metadata.changedOn),
+                token: this.getMetadata().then(metadata => metadata.changedOn),
                 appVersion,
                 appHostId,
             }];
@@ -118,7 +118,7 @@ export default class HTML5Repository {
     }
     downloadAnnotationFile(_uri) {
         log.verbose("No annotation processing in CF");
-        return Promise.resolve(new Map());
+        return Promise.resolve("");
     }
 }
 __decorate([

package/dist/repositories/localRepository.d.ts

@@ -4,7 +4,7 @@ export interface ILocalResource extends ICachedResource {
     absolutePath: string;
 }
 export default class LocalRepository implements IRepository {
-    downloadAnnotationFile(_uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(_uri: string): Promise<string>;
     getAppVariantIdHierarchy(appId: string): Promise<ILocalResource[]>;
     fetch(resource: ILocalResource): Promise<Map<string, Buffer>>;
     private buildManifestIndex;

package/dist/repositories/localRepository.js

@@ -7,7 +7,7 @@ const log = getLogger("@ui5/task-adaptation::LocalRepository");
 export default class LocalRepository {
     async downloadAnnotationFile(_uri) {
         log.verbose("Downloading annotation files is not supported in LocalRepository.");
-        return new Map();
+        return "";
     }
     async getAppVariantIdHierarchy(appId) {
         const items = [];
@@ -26,7 +26,7 @@ export default class LocalRepository {
             }
             items.push({
                 appName: currentAppId,
-                cacheBusterToken: Promise.resolve("local"),
+                token: Promise.resolve("local"),
                 absolutePath: entry.absolutePath,
             });
             if (entry.isVariant) {

package/dist/repositories/repository.d.ts

@@ -2,5 +2,5 @@ import ICachedResource from "../cache/cachedResource.js";
 export default interface IRepository {
     getAppVariantIdHierarchy(appId: string): Promise<ICachedResource[]>;
     fetch(resource: ICachedResource): Promise<Map<string, Buffer>>;
-    downloadAnnotationFile(uri: string): Promise<Map<string, string>>;
+    downloadAnnotationFile(uri: string): Promise<string>;
 }

package/dist/util/cfUtil.d.ts

@@ -10,10 +10,9 @@ export default class CFUtil {
      */
     static getServiceInstanceKeys(getServiceInstanceParams: IGetServiceInstanceParams, createServiceInstanceParams?: ICreateServiceInstanceParams): Promise<IServiceKeys>;
     static createService(params: ICreateServiceInstanceParams): Promise<void>;
-    private static getOrCreateServiceKeys;
-    private static getServiceKeys;
+    private static getOrCreateCredentials;
+    private static fetchCredentials;
     private static createServiceKey;
-    private static deleteServiceKeyUnsafe;
     private static getServiceInstance;
     static processCfErrors(errors?: ICfError[]): void;
     static requestCfApi(url: string): Promise<IResource[]>;
@@ -22,14 +21,15 @@ export default class CFUtil {
     private static errorsToString;
     private static parseJson;
     /**
-     * Get service keys and return the first one with valid endpoints
+     * Return the most recently created service credential binding (key) for the given service instance,
+     * or undefined if no keys exist.
      * @private
      * @static
      * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<ServiceCredentials | null>} the first service key with valid endpoints, or null if none found
+     * @return {Promise<any | undefined>} the newest binding object ({ name, guid, created_at, … }) or undefined
      * @memberof CFUtil
      */
-    private static getServiceKeyWithValidEndpoints;
+    private static getNewestServiceKey;
     /**
      * Get service keys for a service instance by name. If the existing service key
      * has endpoints as strings instead of objects, a new service key will be created.
@@ -49,24 +49,6 @@ export default class CFUtil {
      * @memberof CFUtil
      */
     private static hasValidEndpoints;
-    /**
-     * Get all service key names for a service instance
-     * @private
-     * @static
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string[]>} promise with array of service key names
-     * @memberof CFUtil
-     */
-    private static getAllServiceKeyNames;
-    /**
-     * Generate a unique service key name in format serviceInstanceName-key-N
-     * @static
-     * @param {string} serviceInstanceName the service instance name
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string>} promise with unique service key name
-     * @memberof CFUtil
-     */
-    static generateUniqueServiceKeyName(serviceInstanceName: string, serviceInstanceGuid: string): Promise<string>;
     /**
      * Get space guid from configuration or local CF fodler
      * @static

package/dist/util/cfUtil.js

@@ -1,7 +1,6 @@
-import { cfCreateService, cfGetInstanceCredentials } from "@sap/cf-tools/out/src/cf-local.js";
+import { cfCreateService } from "@sap/cf-tools/out/src/cf-local.js";
 import { getSpaceGuidThrowIfUndefined } from "@sap/cf-tools/out/src/utils.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";
 import AuthenticationError from "../model/authenticationError.js";
 const log = getLogger("@ui5/task-adaptation::CFUtil");
@@ -25,12 +24,12 @@ export default class CFUtil {
         }
         // 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)) {
+        const credentials = await this.getOrCreateCredentials(serviceInstances[0]);
+        if (!credentials) {
             throw new Error(`Cannot get service keys for '${getServiceInstanceParams.names?.join(", ")}' service in current space: ${getServiceInstanceParams.spaceGuids?.join(", ")}`);
         }
         return {
-            credentials: serviceKeys[0].credentials,
+            credentials,
             serviceInstance: serviceInstances[0]
         };
     }
@@ -52,27 +51,28 @@ export default class CFUtil {
             throw new Error(`Cannot create a service instance '${params.serviceInstanceName}' in space '${params.spaceGuid}': ${error.message}`);
         }
     }
-    static async getOrCreateServiceKeys(serviceInstance) {
-        const credentials = await this.getServiceKeys(serviceInstance.guid);
-        if (credentials.length === 0) {
+    static async getOrCreateCredentials(serviceInstance) {
+        if (serviceInstance.type === "user-provided") {
+            log.verbose(`Service instance '${serviceInstance.name}' is user-provided, fetching credentials directly`);
+            return this.fetchCredentials(`/v3/service_instances/${serviceInstance.guid}/credentials`);
+        }
+        let key = await this.getNewestServiceKey(serviceInstance.guid);
+        if (key == null) {
             const serviceKeyName = serviceInstance.name + "_key";
             log.info(`Creating service key '${serviceKeyName}' for service instance '${serviceInstance.name}'`);
             await this.createServiceKey(serviceInstance.name, serviceKeyName);
+            key = await this.getNewestServiceKey(serviceInstance.guid);
+            if (key == null) {
+                throw new Error(`Service key was created for '${serviceInstance.name}' but could not be retrieved`);
+            }
         }
-        else {
-            return credentials;
-        }
-        return this.getServiceKeys(serviceInstance.guid);
+        log.verbose(`Using service key '${key.name}' for service instance '${serviceInstance.name}'`);
+        return this.fetchCredentials(`/v3/service_credential_bindings/${key.guid}/details`);
     }
-    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 fetchCredentials(url) {
+        const parsed = this.parseJson(await this.cfExecute(["curl", url]));
+        this.processCfErrors(parsed?.errors);
+        return parsed.credentials;
     }
     static async createServiceKey(serviceInstanceName, serviceKeyName) {
         try {
@@ -82,12 +82,6 @@ export default class CFUtil {
             throw new Error(`Couldn't create a service key for instance: ${serviceInstanceName}: ${error}`);
         }
     }
-    static deleteServiceKeyUnsafe(serviceInstanceName, serviceKeyName) {
-        // Fire and forget - async delete without waiting for result or handling errors
-        this.cfExecute(["delete-service-key", serviceInstanceName, serviceKeyName, "-f"]).catch(() => {
-            // Ignore any errors - this is intentionally unsafe
-        });
-    }
     static async getServiceInstance(params) {
         const PARAM_MAP = {
             spaceGuids: "space_guids",
@@ -101,7 +95,8 @@ export default class CFUtil {
         const resources = await this.requestCfApi(uri);
         return resources.map((service) => ({
             name: service.name,
-            guid: service.guid
+            guid: service.guid,
+            type: service.type
         }));
     }
     static processCfErrors(errors) {
@@ -174,18 +169,21 @@ export default class CFUtil {
         }
     }
     /**
-     * Get service keys and return the first one with valid endpoints
+     * Return the most recently created service credential binding (key) for the given service instance,
+     * or undefined if no keys exist.
      * @private
      * @static
      * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<ServiceCredentials | null>} the first service key with valid endpoints, or null if none found
+     * @return {Promise<any | undefined>} the newest binding object ({ name, guid, created_at, … }) or undefined
      * @memberof CFUtil
      */
-    static async getServiceKeyWithValidEndpoints(serviceInstanceGuid) {
+    static async getNewestServiceKey(serviceInstanceGuid) {
         try {
-            const serviceKeys = await this.getServiceKeys(serviceInstanceGuid);
-            // Find and return the first key with valid endpoints
-            return serviceKeys.find((key) => key.credentials?.endpoints && this.hasValidEndpoints(key.credentials.endpoints));
+            const keyList = await this.requestCfApi(`/v3/service_credential_bindings?type=key&service_instance_guids=${serviceInstanceGuid}`);
+            if (!keyList?.length) {
+                return undefined;
+            }
+            return keyList.toSorted((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
         }
         catch (error) {
             throw new Error("Failed to get service credentials: " + error.message);
@@ -212,30 +210,11 @@ export default class CFUtil {
         }
         const serviceInstance = serviceInstances[0];
         log.verbose(`Found service instance '${serviceInstance.name}' with guid: ${serviceInstance.guid}`);
-        // If no valid service key found, create a new one with unique name
-        const uniqueServiceKeyNamePromise = this.generateUniqueServiceKeyName(serviceInstance.name, serviceInstance.guid);
-        // Get service keys with credentials to find any with valid endpoints:
-        // object with url and destination instead of a single url string
-        const validKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
-        if (validKey) {
-            log.verbose(`Using existing service key with valid endpoints structure`);
-            return validKey.credentials;
-        }
-        const uniqueServiceKeyName = await uniqueServiceKeyNamePromise;
-        log.verbose(`No valid service key found with proper endpoints structure. Creating new service key '${uniqueServiceKeyName}' for '${serviceInstance.name}'`);
-        await this.createServiceKey(serviceInstance.name, uniqueServiceKeyName);
-        // Get the newly created service key and validate its endpoints
-        const newValidKey = await this.getServiceKeyWithValidEndpoints(serviceInstance.guid);
-        if (newValidKey) {
-            log.verbose(`Using newly created service key with valid endpoints structure`);
-            return newValidKey.credentials;
+        const credentials = await this.getOrCreateCredentials(serviceInstance);
+        if (!credentials?.endpoints || !this.hasValidEndpoints(credentials.endpoints)) {
+            log.info(`Service key for '${serviceInstance.name}' does not have endpoints with service urls for xs-app.json update`);
         }
-        // Clean up the created service key since it doesn't have valid
-        // endpoints. We don't throw an error here even if no valid endpoints
-        // found. We assume that there might be no coincidence between
-        // credential endpoints and xs-app.json destinations.
-        this.deleteServiceKeyUnsafe(serviceInstance.name, uniqueServiceKeyName);
-        log.verbose(`Created service key '${uniqueServiceKeyName}' does not have valid endpoints structure. Triggered deletion of invalid service key '${uniqueServiceKeyName}'`);
+        return credentials;
     }
     /**
      * Check if endpoints object has at least one property that is an object
@@ -252,42 +231,6 @@ export default class CFUtil {
         // Check if at least one property of endpoints is an object
         return Object.values(endpoints).some(value => value && typeof value === 'object' && !Array.isArray(value));
     }
-    /**
-     * Get all service key names for a service instance
-     * @private
-     * @static
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string[]>} promise with array of service key names
-     * @memberof CFUtil
-     */
-    static async getAllServiceKeyNames(serviceInstanceGuid) {
-        try {
-            const serviceKeys = await this.requestCfApi(`/v3/service_credential_bindings?type=key&service_instance_guids=${serviceInstanceGuid}`);
-            return serviceKeys.map((key) => key.name);
-        }
-        catch (error) {
-            throw new Error(`Failed to get service key names: ${error.message}`);
-        }
-    }
-    /**
-     * Generate a unique service key name in format serviceInstanceName-key-N
-     * @static
-     * @param {string} serviceInstanceName the service instance name
-     * @param {string} serviceInstanceGuid the service instance guid
-     * @return {Promise<string>} promise with unique service key name
-     * @memberof CFUtil
-     */
-    static async generateUniqueServiceKeyName(serviceInstanceName, serviceInstanceGuid) {
-        const existingKeyNames = await this.getAllServiceKeyNames(serviceInstanceGuid);
-        let counter = 0;
-        let keyName;
-        do {
-            keyName = `${serviceInstanceName}-key-${counter}`;
-            counter++;
-        } while (existingKeyNames.includes(keyName));
-        log.verbose(`Generated unique service key name: ${keyName}`);
-        return keyName;
-    }
     /**
      * Get space guid from configuration or local CF fodler
      * @static

package/dist/util/commonUtil.d.ts

@@ -1,6 +1,4 @@
-import { IConfiguration } from "../model/types.js";
-import Language from "../model/language.js";
-import AppVariant from "../appVariant.js";
+export declare function retryOnError(maxRetries: number): MethodDecorator;
 export declare function dotToUnderscore(value: string): string;
 export declare function bufferToString(buffer: Buffer): string;
 export declare function bufferToJson(buffer: Buffer): any;
@@ -11,15 +9,9 @@ export declare function validateConfiguration<T extends object>(options: T, prop
 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 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 trimExtension(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;
 export declare function isManifestChange(filename: string, content: Buffer): boolean;
-/**
- * 4p. Reference map contains searchTerm as key and replacement as value. Base
- * id and app variant ids are renamed to adaptation project id.
- */
-export declare function getReferences(appVariants: AppVariant[], adaptationProjectId: string): Map<string, string>;