@ui5/task-adaptation 1.5.0 → 1.5.2-rc.0

package/dist/bundle.js

@@ -4955,30 +4955,31 @@ var FilterOperator = {
   EndsWith: "EndsWith",
   NotEndsWith: "NotEndsWith",
   All: "All",
-  Any: "Any"
+  NotAll: "NotAll",
+  Any: "Any",
+  NotAny: "NotAny"
 };
 
-class config {
-    config = new Map();
-    static get Type() {
-        return {
-            String: "string"
-        }
-    }
-    static get({ name }) {
-        return name === "sapUiLogLevel" ? "Error" : undefined;
-    }
-    static getWritableInstance() {
-        return {
-            get(obj) {
-                config.get(obj.name);
-            },
-            set(name, obj) {
-                config.set(name, obj);
-            }
-        }
+const _Configuration = {
+  _: {}
+};
+const internalConfig = new Map();
+_Configuration.getWritableInstance = () => {
+  return {
+    get(obj) {
+      internalConfig.get(obj.name);
+    },
+    set(name, obj) {
+      internalConfig.set(name, obj);
     }
-}
+  };
+};
+function attachInvalidated() {}
+_Configuration._.attachInvalidated = attachInvalidated;
+const origInvalidate = _Configuration._.invalidate;
+_Configuration._.invalidate = () => {
+  origInvalidate();
+};
 
 class Eventing {
 		#mEventRegistry = {};
@@ -5210,6 +5211,11 @@ class LanguageTag {
 		 */
 		privateUseSubtags;
 
+		/**
+		 * @private
+		 */
+		#tagAsString;
+
 		constructor(sLanguageTag) {
 			var aResult = rLanguageTag.exec(sLanguageTag.replace(/_/g, "-"));
 			// If the given language tag string cannot be parsed by the regular expression above,
@@ -5241,16 +5247,17 @@ class LanguageTag {
 			if ( this.region ) {
 				this.region = this.region.toUpperCase();
 			}
-			Object.freeze(this);
-		}
-		toString() {
-			return this.#join(
+			this.#tagAsString = this.#join(
 				this.language,
 				this.script,
 				this.region,
 				this.variant,
 				this.extension,
 				this.privateUse);
+			Object.freeze(this);
+		}
+		toString() {
+			return this.#tagAsString;
 		}
 		#join() {
 			return Array.prototype.filter.call(arguments, Boolean).join("-");
@@ -5550,11 +5557,15 @@ TimezoneUtils._clearLocalTimezoneCache = function () {
   sLocalTimezone = "";
 };
 
-const oWritableConfig = config.getWritableInstance();
+const oWritableConfig = _Configuration.getWritableInstance();
 let sLanguageSetByApi;
 const oEventing = new Eventing();
+let mCache = Object.create(null);
 let mChanges;
 let bLanguageWarningLogged = false;
+_Configuration._.attachInvalidated(() => {
+  mCache = Object.create(null);
+});
 const _mPreferredCalendar = {
   "ar-SA": CalendarType.Islamic,
   "fa": CalendarType.Persian,
@@ -5615,9 +5626,11 @@ function createLanguageTag(sLanguage) {
   }
   return oLanguageTag;
 }
-function detectLanguage() {
-  return globalThis.navigator ? globalThis.navigator.languages && globalThis.navigator.languages[0] || globalThis.navigator.language || "en" : new Intl.Collator().resolvedOptions().locale || "en";
-}
+const detectLanguage = globalThis.navigator ? function () {
+  return globalThis.navigator.languages?.[0] || globalThis.navigator.language || "en";
+} : function () {
+  return new Intl.Collator().resolvedOptions().locale || "en";
+};
 function check(bCondition, sMessage) {
   if (!bCondition) {
     throw new TypeError(sMessage);
@@ -5643,29 +5656,32 @@ const Localization = {
   getActiveTerminologies: function () {
     return oWritableConfig.get({
       name: "sapUiActiveTerminologies",
-      type: config.Type.StringArray,
+      type: _Configuration.Type.StringArray,
       defaultValue: undefined,
       external: true
     });
   },
   getLanguage: function () {
     let oLanguageTag, sDerivedLanguage;
+    if (mCache.language) {
+      return mCache.language;
+    }
     if (sLanguageSetByApi) {
       return sLanguageSetByApi;
     }
     const sLanguage = oWritableConfig.get({
       name: "sapUiLanguage",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true
     });
     const sSapLocale = oWritableConfig.get({
       name: "sapLocale",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true
     });
     const sSapLanguage = oWritableConfig.get({
       name: "sapLanguage",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true
     });
     if (sSapLocale) {
@@ -5680,14 +5696,15 @@ const Localization = {
     }
     if (!oLanguageTag) {
       if (sLanguage) {
-        oLanguageTag = createLanguageTag(sLanguage);
+        createLanguageTag(sLanguage);
         sDerivedLanguage = sLanguage;
       } else {
         sDerivedLanguage = detectLanguage();
-        oLanguageTag = createLanguageTag(sLanguage);
+        createLanguageTag(sLanguage);
       }
     }
-    return sDerivedLanguage;
+    mCache.language = sDerivedLanguage;
+    return mCache.language;
   },
   getModernLanguage: function (sLanguage) {
     return M_ISO639_OLD_TO_NEW[sLanguage] || sLanguage;
@@ -5699,7 +5716,7 @@ const Localization = {
     sSAPLogonLanguage = sSAPLogonLanguage || "";
     if (oLanguageTag.toString() != Localization.getLanguageTag().toString() || sSAPLogonLanguage !== oWritableConfig.get({
       name: "sapLanguage",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true
     })) {
       oWritableConfig.set("sapLanguage", sSAPLogonLanguage);
@@ -5714,20 +5731,24 @@ const Localization = {
     }
   },
   getTimezone: function () {
+    if (mCache.timezone) {
+      return mCache.timezone;
+    }
     let sTimezone = oWritableConfig.get({
       name: "sapTimezone",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true,
       defaultValue: oWritableConfig.get({
         name: "sapUiTimezone",
-        type: config.Type.String,
+        type: _Configuration.Type.String,
         external: true
       })
     });
     if (!sTimezone || !checkTimezone(sTimezone)) {
       sTimezone = TimezoneUtils.getLocalTimezone();
     }
-    return sTimezone;
+    mCache.timezone = sTimezone;
+    return mCache.timezone;
   },
   setTimezone: function (sTimezone) {
     check(sTimezone == null || typeof sTimezone === "string", "Localization.setTimezone: sTimezone must be null or be a string");
@@ -5741,6 +5762,9 @@ const Localization = {
     }
   },
   getLanguageTag: function () {
+    if (mCache.languageTag) {
+      return mCache.languageTag;
+    }
     const oLanguageTag = new LanguageTag(Localization.getLanguage());
     const sLanguage = Localization.getModernLanguage(oLanguageTag.language);
     const sScript = oLanguageTag.script;
@@ -5750,22 +5774,27 @@ const Localization = {
     } else {
       sLanguageTag = sLanguageTag.replace(oLanguageTag.language, sLanguage);
     }
-    return new LanguageTag(sLanguageTag);
+    mCache.languageTag = new LanguageTag(sLanguageTag);
+    return mCache.languageTag;
   },
   getRTL: function () {
-    return oWritableConfig.get({
+    if (mCache.rtl) {
+      return mCache.rtl;
+    }
+    mCache.rtl = oWritableConfig.get({
       name: "sapRtl",
-      type: config.Type.Boolean,
+      type: _Configuration.Type.Boolean,
       external: true,
       defaultValue: oWritableConfig.get({
         name: "sapUiRtl",
-        type: config.Type.Boolean,
+        type: _Configuration.Type.Boolean,
         defaultValue: function () {
           return impliesRTL(Localization.getLanguageTag());
         },
         external: true
       })
     });
+    return mCache.rtl;
   },
   setRTL: function (bRTL) {
     check(bRTL === null || typeof bRTL === "boolean", "bRTL must be null or a boolean");
@@ -5794,7 +5823,7 @@ const Localization = {
     let oLanguageTag;
     const sLanguage = oWritableConfig.get({
       name: "sapLanguage",
-      type: config.Type.String,
+      type: _Configuration.Type.String,
       external: true
     }).toUpperCase();
     try {
@@ -5813,9 +5842,9 @@ const Localization = {
     return _coreI18nLocales;
   },
   getSupportedLanguages: function () {
-    let aLangs = config.get({
+    let aLangs = _Configuration.get({
       name: "sapUiXxSupportedLanguages",
-      type: config.Type.StringArray,
+      type: _Configuration.Type.StringArray,
       external: true
     });
     if (aLangs.length === 0 || aLangs.length === 1 && aLangs[0] === "*") {
@@ -5870,8 +5899,8 @@ var Filter = BaseObject.extend("sap.ui.model.Filter", {
       }
       this.oValue1 = vValue1;
       this.oValue2 = vValue2;
-      if (this.sOperator === FilterOperator.Any || this.sOperator === FilterOperator.All) {
-        throw new Error("The filter operators 'Any' and 'All' are only supported with the parameter object notation.");
+      if (this.sOperator === FilterOperator.Any || this.sOperator === FilterOperator.All || this.sOperator === FilterOperator.NotAny || this.sOperator === FilterOperator.NotAll) {
+        throw new Error("The filter operators 'Any', 'All', 'NotAny', and 'NotAll' are only supported with " + "the parameter object notation.");
       }
     }
     if (this.aFilters?.includes(Filter.NONE)) {
@@ -5879,13 +5908,13 @@ var Filter = BaseObject.extend("sap.ui.model.Filter", {
     } else if (this.oCondition && this.oCondition === Filter.NONE) {
       throw new Error("Filter.NONE not allowed as condition");
     }
-    if (this.sOperator === FilterOperator.Any) {
+    if (this.sOperator === FilterOperator.Any || this.sOperator === FilterOperator.NotAny) {
       if (this.sVariable && this.oCondition) {
         this._checkLambdaArgumentTypes();
       } else if (!this.sVariable && !this.oCondition) ; else {
-        throw new Error("When using the filter operator 'Any', a lambda variable and a condition have to be given or neither.");
+        throw new Error("When using the filter operator 'Any' or 'NotAny', you need to provide " + "both a lambda variable and a condition, or neither.");
       }
-    } else if (this.sOperator === FilterOperator.All) {
+    } else if (this.sOperator === FilterOperator.All || this.sOperator === FilterOperator.NotAll) {
       this._checkLambdaArgumentTypes();
     } else if (Array.isArray(this.aFilters) && !this.sPath && !this.sOperator && !this.oValue1 && !this.oValue2) {
       this._bMultiFilter = true;
@@ -5912,10 +5941,10 @@ Filter.checkFilterNone = function (vFilter) {
 };
 Filter.prototype._checkLambdaArgumentTypes = function () {
   if (!this.sVariable || typeof this.sVariable !== "string") {
-    throw new Error("When using the filter operators 'Any' or 'All', a string has to be given as argument 'variable'.");
+    throw new Error("When using the filter operators 'Any', 'All', 'NotAny', or 'NotAll', a string has to be " + "given as the 'variable' argument.");
   }
   if (!isFilter(this.oCondition)) {
-    throw new Error("When using the filter operator 'Any' or 'All', a valid instance of sap.ui.model.Filter has to be given as argument 'condition'.");
+    throw new Error("When using the filter operator 'Any', 'All', 'NotAny', or 'NotAll', a valid instance of " + "sap.ui.model.Filter has to be given as the 'condition' argument.");
   }
 };
 function isFilter(v) {
@@ -5955,7 +5984,7 @@ var Func = {
   EndsWith: "endswith"
 };
 Filter.prototype.getAST = function (bIncludeOrigin) {
-  var oResult, sOp, sOrigOp, oRef, oValue, oFromValue, oToValue, oVariable, oCondition;
+  var oResult, sOp, sOrigOp, oRef, oValue, oFromValue, oToValue;
   function logical(sOp, oLeft, oRight) {
     return {
       type: Type.Logical,
@@ -6074,10 +6103,19 @@ Filter.prototype.getAST = function (bIncludeOrigin) {
         break;
       case FilterOperator.Any:
       case FilterOperator.All:
-        oVariable = variable(this.sVariable);
-        oCondition = this.oCondition.getAST(bIncludeOrigin);
-        oResult = lambda(sOp, oRef, oVariable, oCondition);
-        break;
+      case FilterOperator.NotAny:
+      case FilterOperator.NotAll:
+        {
+          let sOpLambda = sOp;
+          if (sOp === FilterOperator.NotAny) {
+            sOpLambda = FilterOperator.Any;
+          } else if (sOp === FilterOperator.NotAll) {
+            sOpLambda = FilterOperator.All;
+          }
+          const oLambda = lambda(sOpLambda, oRef, variable(this.sVariable), this.oCondition.getAST(bIncludeOrigin));
+          oResult = sOp === FilterOperator.NotAny || sOp === FilterOperator.NotAll ? unary(Op.Not, oLambda) : oLambda;
+          break;
+        }
       default:
         throw new Error("Unknown operator: " + sOp);
     }

package/dist/index.js

@@ -17,34 +17,57 @@ export default ({ workspace, options, taskUtil }) => {
         const processor = determineProcessor(options.configuration);
         const adaptationProject = await AppVariant.fromWorkspace(workspace, options.projectNamespace);
         const appVariantIdHierarchy = await processor.getAppVariantIdHierarchy(adaptationProject.reference);
+        if (appVariantIdHierarchy.length === 0) {
+            throw new Error(`No app variant found for reference ${adaptationProject.reference}`);
+        }
         // appVariantIdHierarchy contains original application on bottom and the
         // latest app variant on top. We reverse the list to process original
         // application first and then app variants in chronological order.
         const reversedHierarchy = appVariantIdHierarchy.toReversed();
         const fetchFilesPromises = reversedHierarchy.map(({ repoName, cachebusterToken }) => processor.fetch(repoName, cachebusterToken));
         fetchFilesPromises.push(Promise.resolve(adaptationProject.files));
+        const appVariants = new Array();
         const adapt = async (baseAppFiles, appVariantFiles) => {
-            const baseApp = BaseApp.fromFiles(baseAppFiles);
-            const appVariant = AppVariant.fromFiles(appVariantFiles);
+            let baseApp = BaseApp.fromFiles(baseAppFiles);
+            let appVariant = AppVariant.fromFiles(appVariantFiles);
+            // If the app variant is the same as the adaptation project, we use the
+            // adaptation project because it contains resources that should be updated.
+            if (appVariant.id === adaptationProject.id) {
+                appVariant = adaptationProject;
+            }
+            appVariants.push(appVariant);
             const adaptedFiles = await baseApp.adapt(appVariant, processor);
             return I18nMerger.merge(adaptedFiles, baseApp.i18nPath, appVariant);
         };
-        let files = await fetchFilesPromises.reduce(async (previousFiles, currentFiles) => {
-            return adapt(await previousFiles, await currentFiles);
-        }, fetchFilesPromises.shift());
-        if (files) {
-            const references = appVariantIdHierarchy.map(item => item.appVariantId);
-            files = FilesUtil.filter(files);
-            files = FilesUtil.rename(files, references, adaptationProject.id);
-            adaptationProject.omitDeletedResources(files, options.projectNamespace, taskUtil);
-            const writePromises = new Array();
-            files.forEach((content, filename) => {
-                const resource = ResourceUtil.createResource(filename, options.projectNamespace, content);
-                writePromises.push(workspace.write(resource));
-            });
-            await Promise.all(writePromises);
-        }
+        let files = await fetchFilesPromises.reduce(async (previousFiles, currentFiles) => adapt(await previousFiles, await currentFiles), fetchFilesPromises.shift());
+        const references = getReferences(appVariants, adaptationProject.id);
+        files = FilesUtil.filter(files);
+        files = FilesUtil.rename(files, references);
+        adaptationProject.omitDeletedResources(files, options.projectNamespace, taskUtil);
+        const writePromises = new Array();
+        files.forEach((content, filename) => {
+            const resource = ResourceUtil.createResource(filename, options.projectNamespace, content);
+            writePromises.push(workspace.write(resource));
+        });
+        await Promise.all(writePromises);
     }
     return process(workspace, taskUtil);
+    /**
+     * 4p. Reference map contains searchTerm as key and replacement as value. Base
+     * id and app variant ids are renamed to adaptation project id.
+     */
+    function getReferences(appVariants, adaptationProjectId) {
+        const references = new Map();
+        appVariants.forEach((variant, i) => {
+            if (i === 0) {
+                references.set(variant.reference, adaptationProjectId);
+            }
+            if (variant.id !== adaptationProjectId) {
+                references.set(variant.id, adaptationProjectId);
+            }
+            variant.getRenamingForMovedFiles().forEach((value, key) => references.set(key, value));
+        });
+        return references;
+    }
 };
 //# sourceMappingURL=index.js.map

package/dist/model/configuration.d.ts

@@ -14,6 +14,7 @@ export interface IConfiguration {
     enableBetaFeatures?: boolean;
     writeTempFiles?: any;
     target?: AbapTarget & IAbapTargetMeta;
+    serviceInstanceName?: string;
 }
 export interface IAbapTargetMeta {
     name?: string;

package/dist/processors/abapProcessor.d.ts

@@ -11,7 +11,7 @@ export default class AbapProcessor implements IProcessor {
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
     fetch(repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
     validateConfiguration(): void;
-    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
     getConfigurationType(): string;
     createAppVariantHierarchyItem(appVariantId: string, version: string): {
         appVariantId: string;

package/dist/processors/abapProcessor.js

@@ -27,9 +27,9 @@ export default class AbapProcessor {
         const properties = ["appName"];
         validateObject(this.configuration, properties, "should be specified in ui5.yaml configuration");
     }
-    async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles, appVariantId) {
+    async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles, appVariantId, prefix) {
         const languages = Language.create(this.configuration.languages);
-        const files = await this.annotationManager.process(baseAppManifest, languages, appVariantId);
+        const files = await this.annotationManager.process(baseAppManifest, languages, appVariantId, prefix);
         if (baseAppFiles) {
             files.forEach((value, key) => baseAppFiles.set(key, value));
         }

package/dist/processors/cfProcessor.d.ts

@@ -7,7 +7,9 @@ export default class CFProcessor implements IProcessor {
     getAppVariantIdHierarchy(appId: string): Promise<IAppInfo[]>;
     fetch(_repoName: string, _cachebusterToken: string): Promise<Map<string, string>>;
     validateConfiguration(): void;
-    updateLandscapeSpecificContent(renamedBaseAppManifest: any): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>): Promise<void>;
+    private updateXsAppJson;
+    private enhanceRoutesWithEndpointAndService;
     private updateCloudPlatform;
     getConfigurationType(): string;
     createAppVariantHierarchyItem(appVariantId: string, version: string): {

package/dist/processors/cfProcessor.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import HTML5RepoManager from "../repositories/html5RepoManager.js";
 import { cached } from "../cache/cacheHolder.js";
 import { validateObject } from "../util/commonUtil.js";
+import CFUtil from "../util/cfUtil.js";
 export default class CFProcessor {
     configuration;
     constructor(configuration) {
@@ -26,8 +27,56 @@ export default class CFProcessor {
     validateConfiguration() {
         validateObject(this.configuration, ["appHostId", "appName", "appVersion"], "should be specified in ui5.yaml configuration");
     }
-    async updateLandscapeSpecificContent(renamedBaseAppManifest) {
-        this.updateCloudPlatform(renamedBaseAppManifest);
+    async updateLandscapeSpecificContent(baseAppManifest, baseAppFiles) {
+        this.updateCloudPlatform(baseAppManifest);
+        await this.updateXsAppJson(baseAppFiles);
+    }
+    async updateXsAppJson(baseAppFiles) {
+        const xsAppJsonContent = baseAppFiles.get("xs-app.json");
+        if (!xsAppJsonContent) {
+            return;
+        }
+        const { serviceInstanceName, space } = this.configuration;
+        if (!serviceInstanceName) {
+            throw new Error(`Service instance name must be specified in ui5.yaml configuration for app '${this.configuration.appName}'`);
+        }
+        let serviceCredentials;
+        try {
+            // Get valid service keys with proper endpoints structure
+            serviceCredentials = await CFUtil.getOrCreateServiceKeyWithEndpoints(serviceInstanceName, space);
+        }
+        catch (error) {
+            throw new Error(`Failed to get valid service keys for app '${this.configuration.appName}': ${error.message}`);
+        }
+        const xsAppJson = JSON.parse(xsAppJsonContent);
+        xsAppJson.routes = this.enhanceRoutesWithEndpointAndService(serviceCredentials, xsAppJson.routes);
+        baseAppFiles.set("xs-app.json", JSON.stringify(xsAppJson, null, 2));
+    }
+    enhanceRoutesWithEndpointAndService(serviceCredentials, baseRoutes) {
+        const endpoints = serviceCredentials.endpoints;
+        // Map destinations to endpoint names
+        const destinationToEndpoint = Object.entries(endpoints).reduce((acc, [endpointName, obj]) => {
+            if (obj.destination) {
+                acc[obj.destination] = endpointName;
+            }
+            return acc;
+        }, {});
+        return baseRoutes.map((route) => {
+            const endpointName = destinationToEndpoint[route.destination];
+            if (endpointName) {
+                // There is a matching endpoint: remove destination and add endpoint/service
+                const { destination: _destination, ...rest } = route;
+                return {
+                    ...rest,
+                    endpoint: endpointName,
+                    service: serviceCredentials["sap.cloud.service"],
+                };
+            }
+            else {
+                // No match: return route unchanged
+                return route;
+            }
+        });
     }
     updateCloudPlatform(baseAppManifest) {
         const sapCloudService = baseAppManifest["sap.cloud"]?.service;

package/dist/processors/processor.d.ts

@@ -4,6 +4,6 @@ export default interface IProcessor {
     getAppVariantIdHierarchy(appId: string): Promise<IAppVariantIdHierarchyItem[]>;
     fetch(repoName: string, cachebusterToken: string): Promise<Map<string, string>>;
     createAppVariantHierarchyItem(appVariantId: string, version: string): void;
-    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: ReadonlyMap<string, string>, appVariantId: string): Promise<void>;
+    updateLandscapeSpecificContent(baseAppManifest: any, baseAppFiles: Map<string, string>, appVariantId: string, prefix: string): Promise<void>;
 }
 export declare function determineProcessor(configuration: IConfiguration): IProcessor;

package/dist/util/cfUtil.d.ts

@@ -13,6 +13,7 @@ export default class CFUtil {
     private static getOrCreateServiceKeys;
     private static getServiceKeys;
     private static createServiceKey;
+    private static deleteServiceKeyUnsafe;
     private static getServiceInstance;
     static processErrors(json: any): void;
     static requestCfApi(url: string): Promise<IResource[]>;
@@ -20,6 +21,52 @@ export default class CFUtil {
     private static cfExecute;
     private static errorsToString;
     private static parseJson;
+    /**
+     * Get service keys and return the first one with valid endpoints
+     * @private
+     * @static
+     * @param {string} serviceInstanceGuid the service instance guid
+     * @return {Promise<any>} the first service key with valid endpoints, or null if none found
+     * @memberof CFUtil
+     */
+    private static getServiceKeyWithValidEndpoints;
+    /**
+     * 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.
+     * @static
+     * @param {string} serviceInstanceName name of the service instance
+     * @param {string} [spaceGuid] optional space guid, will use current space if not provided
+     * @return {Promise<any>} promise with service key credentials
+     * @memberof CFUtil
+     */
+    static getOrCreateServiceKeyWithEndpoints(serviceInstanceName: string, spaceGuid?: string): Promise<any>;
+    /**
+     * Check if endpoints object has at least one property that is an object
+     * @private
+     * @static
+     * @param {any} endpoints the endpoints object to validate
+     * @return {boolean} true if at least one property of endpoints is an object
+     * @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