mcdev 6.0.2 → 7.0.0

package/lib/metadataTypes/EmailSend.js

@@ -1,10 +1,22 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import cache from '../util/cache.js';
 
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+
 /**
  * MessageSendActivity MetadataType
  *
@@ -14,14 +26,14 @@ class EmailSend extends MetadataType {
     /**
      * Retrieves SOAP based metadata of metadata type into local filesystem. executes callback with retrieved metadata
      *
-     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {string} [retrieveDir] Directory where retrieved metadata directory will be saved
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
-        /** @type {TYPE.SoapRequestParams} */
+        /** @type {SoapRequestParams} */
         let requestParams = {
             filter: {
                 leftOperand: {
@@ -58,7 +70,7 @@ class EmailSend extends MetadataType {
     /**
      * Updates a single item
      *
-     * @param {TYPE.MetadataTypeItem} metadataItem a single item
+     * @param {MetadataTypeItem} metadataItem a single item
      * @returns {Promise} Promise
      */
     static update(metadataItem) {
@@ -68,7 +80,7 @@ class EmailSend extends MetadataType {
     /**
      * Creates a single item
      *
-     * @param {TYPE.MetadataTypeItem} metadataItem a single item
+     * @param {MetadataTypeItem} metadataItem a single item
      * @returns {Promise} Promise
      */
     static create(metadataItem) {
@@ -88,8 +100,8 @@ class EmailSend extends MetadataType {
     /**
      * prepares a single item for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single script activity definition
-     * @returns {Promise.<TYPE.MetadataTypeItem>} Promise
+     * @param {MetadataTypeItem} metadata a single script activity definition
+     * @returns {Promise.<MetadataTypeItem>} Promise
      */
     static async preDeployTasks(metadata) {
         // re-add IsPlatformObject, required for visibility
@@ -98,24 +110,24 @@ class EmailSend extends MetadataType {
         super.setFolderId(metadata);
         // email; in case we still have Email.ID, keep it but warn
         metadata.Email ||= {};
-        if (metadata.r__email_Name) {
+        if (metadata.r__email_name) {
             // classic
-            metadata.Email.ID = cache.searchForField('email', metadata.r__email_Name, 'Name', 'ID');
-            delete metadata.r__email_Name;
-        } else if (metadata.r__assetMessage_Key) {
+            metadata.Email.ID = cache.searchForField('email', metadata.r__email_name, 'Name', 'ID');
+            delete metadata.r__email_name;
+        } else if (metadata.r__asset_key) {
             // content builder
-            // * this ignores r__assetMessage_Name on purpose\ as that is only unique per parent folder but useful during PR reviews
+            // * this ignores r__asset_name_readOnly on purpose\ as that is only unique per parent folder but useful during PR reviews
             // will try to find the key with the bu mid at the end, if unable, will try to find the key without it
             try {
                 // check asset key as provided
                 metadata.Email.ID = cache.searchForField(
                     'asset',
-                    metadata.r__assetMessage_Key,
+                    metadata.r__asset_key,
                     'customerKey',
                     'legacyData.legacyId'
                 );
-                delete metadata.r__assetMessage_Key;
-                delete metadata.r__assetMessage_Name;
+                delete metadata.r__asset_key;
+                delete metadata.r__asset_name_readOnly;
             } catch {
                 // if we deploy to another BU, try applying the BU's MID to the end, which we do in preDeployTasks for assets
 
@@ -124,18 +136,18 @@ class EmailSend extends MetadataType {
 
                 metadata.Email.ID = cache.searchForField(
                     'asset',
-                    metadata.r__assetMessage_Key.slice(0, Math.max(0, 36 - suffix.length)) + suffix,
+                    metadata.r__asset_key.slice(0, Math.max(0, 36 - suffix.length)) + suffix,
                     'customerKey',
                     'legacyData.legacyId'
                 );
-                delete metadata.r__assetMessage_Key;
-                delete metadata.r__assetMessage_Name;
+                delete metadata.r__asset_key;
+                delete metadata.r__asset_name_readOnly;
             }
         } else if (metadata.Email.ID) {
             Util.logger.warn(
                 ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
                     metadata[this.definition.keyField]
-                }): Email.ID was provided manually in your deployment file. We recommend using r__assetMessage_Key instead.`
+                }): Email.ID was provided manually in your deployment file. We recommend using r__asset_key instead.`
             );
             try {
                 // content builder - test only
@@ -168,22 +180,22 @@ class EmailSend extends MetadataType {
         // - DataSourceTypeID=List --> List is source; DE is not defined
         for (const sdl of metadata.SendDefinitionList) {
             // get DataExtension (optional)
-            if (sdl.r__dataExtension_Key) {
+            if (sdl.r__dataExtension_key) {
                 if (sdl.DataSourceTypeID !== 'CustomObject') {
                     throw new Error(
-                        ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}): Expecting DataSourceTypeID to equal 'CustomObject' when r__dataExtension_Key is defined; Found '${sdl.DataSourceTypeID}'`
+                        `Expecting DataSourceTypeID to equal 'CustomObject' when r__dataExtension_key is defined; Found '${sdl.DataSourceTypeID}'`
                     );
                 }
                 sdl.CustomObjectID = cache.searchForField(
                     'dataExtension',
-                    sdl.r__dataExtension_Key,
+                    sdl.r__dataExtension_key,
                     'CustomerKey',
                     'ObjectID'
                 );
-                delete sdl.r__dataExtension_Key;
+                delete sdl.r__dataExtension_key;
             } else if (sdl.DataSourceTypeID === 'CustomObject') {
                 throw new Error(
-                    ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}): Expecting r__dataExtension_Key to be defined if DataSourceTypeID='CustomObject'`
+                    `Expecting r__dataExtension_key to be defined if DataSourceTypeID='CustomObject'`
                 );
             }
             if (!sdl.SalesForceObjectID || sdl.SalesForceObjectID === '') {
@@ -196,21 +208,57 @@ class EmailSend extends MetadataType {
                     ID: cache.getListObjectId(sdl.r__list_PathName, 'ID'),
                 };
                 delete sdl.r__list_PathName;
-            } else {
+            } else if (sdl.SendDefinitionListType === 'SourceList') {
+                // dont throw an error for type 'ExclusionList'
                 throw new Error(
-                    ` ☇ skipping ${this.definition.type} ${metadata.Name} (${metadata.CustomerKey}) Field SendDefinitionList.r__list_PathName was not defined. Please try re-retrieving this ESD from your source BU.`
+                    `Field SendDefinitionList.r__list_PathName was not defined. Please try re-retrieving this ESD from your source BU.`
                 );
             }
         }
 
+        // sender profile
+        if (metadata.r__senderProfile_key) {
+            cache.searchForField(
+                'senderProfile',
+                metadata.r__senderProfile_key,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SenderProfile = {
+                CustomerKey: metadata.r__senderProfile_key,
+            };
+            delete metadata.r__senderProfile_key;
+        }
+        // send classification
+        if (metadata.r__sendClassification_key) {
+            cache.searchForField(
+                'sendClassification',
+                metadata.r__sendClassification_key,
+                'CustomerKey',
+                'CustomerKey'
+            );
+            metadata.SendClassification = {
+                CustomerKey: metadata.r__sendClassification_key,
+            };
+            delete metadata.r__sendClassification_key;
+        }
+        // delivery profile
+        if (metadata.r__deliveryProfile_key) {
+            cache.searchForField('deliveryProfile', metadata.r__deliveryProfile_key, 'key', 'key');
+            metadata.DeliveryProfile = {
+                CustomerKey: metadata.r__deliveryProfile_key,
+            };
+            delete metadata.r__deliveryProfile_key;
+        }
+
         return metadata;
     }
 
     /**
      * manages post retrieve steps
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single query
-     * @returns {TYPE.MetadataTypeItem} Array with one metadata object and one query string
+     * @param {MetadataTypeItem} metadata a single query
+     * @returns {MetadataTypeItem} Array with one metadata object and one query string
      */
     static postRetrieveTasks(metadata) {
         // remove IsPlatformObject, always has to be 'false'
@@ -228,14 +276,14 @@ class EmailSend extends MetadataType {
                     'legacyData.legacyId',
                     'name'
                 );
-                metadata.r__assetMessage_Name = contentBuilderEmailName;
+                metadata.r__asset_name_readOnly = contentBuilderEmailName;
                 const contentBuilderEmailKey = cache.searchForField(
                     'asset',
                     metadata.Email.ID,
                     'legacyData.legacyId',
                     'customerKey'
                 );
-                metadata.r__assetMessage_Key = contentBuilderEmailKey;
+                metadata.r__asset_key = contentBuilderEmailKey;
                 delete metadata.Email;
             } catch {
                 try {
@@ -246,7 +294,7 @@ class EmailSend extends MetadataType {
                         'ID',
                         'Name'
                     );
-                    metadata.r__email_Name = classicEmail;
+                    metadata.r__email_name = classicEmail;
                     delete metadata.Email;
                 } catch {
                     Util.logger.warn(
@@ -271,7 +319,7 @@ class EmailSend extends MetadataType {
             // get DataExtension keys
             if (sdl.CustomObjectID) {
                 try {
-                    sdl.r__dataExtension_Key = cache.searchForField(
+                    sdl.r__dataExtension_key = cache.searchForField(
                         'dataExtension',
                         sdl.CustomObjectID,
                         'ObjectID',
@@ -307,6 +355,58 @@ class EmailSend extends MetadataType {
             }
         }
 
+        // sender profile
+        if (metadata.SenderProfile?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'senderProfile',
+                    metadata.SenderProfile.CustomerKey,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                metadata.r__senderProfile_key = metadata.SenderProfile.CustomerKey;
+                delete metadata.SenderProfile;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+        // send classification
+        if (metadata.SendClassification?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'sendClassification',
+                    metadata.SendClassification.CustomerKey,
+                    'CustomerKey',
+                    'CustomerKey'
+                );
+                metadata.r__sendClassification_key = metadata.SendClassification.CustomerKey;
+                delete metadata.SendClassification;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+        // delivery profile
+        if (metadata.DeliveryProfile?.CustomerKey) {
+            try {
+                cache.searchForField(
+                    'deliveryProfile',
+                    metadata.DeliveryProfile.CustomerKey,
+                    'key',
+                    'key'
+                );
+                metadata.r__deliveryProfile_key = metadata.DeliveryProfile.CustomerKey;
+                delete metadata.DeliveryProfile;
+            } catch (ex) {
+                Util.logger.warn(
+                    ` - ${this.definition.type} ${metadata.CustomerKey}: ${ex.message}`
+                );
+            }
+        }
+
         return metadata;
     }
 }

package/lib/metadataTypes/Event.js

@@ -1,11 +1,23 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 import { Util } from '../util/util.js';
 import File from '../util/file.js';
 import cache from '../util/cache.js';
 
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+
 /**
  * Event MetadataType
  *
@@ -14,34 +26,46 @@ import cache from '../util/cache.js';
 class Event extends MetadataType {
     /**
      * Retrieves Metadata of Event Definition.
-     * Endpoint /interaction/v1/EventDefinitions return all Event Definitions with all details.
-     * Currently it is not needed to loop over Imports with endpoint /interaction/v1/EventDefinitions/{id}
+     * Endpoint /interaction/v1/eventDefinitions return all Event Definitions with all details.
+     * Currently it is not needed to loop over Imports with endpoint /interaction/v1/eventDefinitions/{id}
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieve(retrieveDir, _, __, key) {
         Util.logBeta(this.definition.type);
-        return super.retrieveREST(
-            retrieveDir,
-            `/interaction/v1/EventDefinitions${
-                key ? '/key:' + encodeURIComponent(key) : ''
-            }?extras=all`,
-            null,
-            key
-        );
+        try {
+            return super.retrieveREST(
+                retrieveDir,
+                `/interaction/v1/eventDefinitions${
+                    key ? '/key:' + encodeURIComponent(key) : ''
+                }?extras=all`,
+                null,
+                key
+            );
+        } catch (ex) {
+            // if the event does not exist, the API returns the error "Request failed with status code 400 (ERR_BAD_REQUEST)" which would otherwise bring execution to a hold
+            if (key && ex.code === 'ERR_BAD_REQUEST') {
+                Util.logger.info(
+                    `Downloaded: ${this.definition.type} (0)${Util.getKeysString(key)}`
+                );
+            } else {
+                throw ex;
+            }
+        }
+        return;
     }
 
     /**
      * Retrieves event definition metadata for caching
      *
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise of metadata
+     * @returns {Promise.<MetadataTypeMapObj>} Promise of metadata
      */
     static retrieveForCache() {
-        return super.retrieveREST(null, '/interaction/v1/EventDefinitions/');
+        return this.retrieve(null);
     }
 
     /**
@@ -49,13 +73,13 @@ class Event extends MetadataType {
      *
      * @param {string} templateDir Directory where retrieved metadata directory will be saved
      * @param {string} name name of the metadata file
-     * @param {TYPE.TemplateMap} templateVariables variables to be replaced in the metadata
-     * @returns {Promise.<TYPE.MetadataTypeItemObj>} Promise of metadata
+     * @param {TemplateMap} templateVariables variables to be replaced in the metadata
+     * @returns {Promise.<MetadataTypeItemObj>} Promise of metadata
      */
     static async retrieveAsTemplate(templateDir, name, templateVariables) {
         Util.logBeta(this.definition.type);
         const res = await this.client.rest.get(
-            '/interaction/v1/EventDefinitions?name=' + encodeURIComponent(name)
+            '/interaction/v1/eventDefinitions?name=' + encodeURIComponent(name)
         );
         const event = res.items.filter((item) => item.name === name);
         try {
@@ -70,13 +94,13 @@ class Event extends MetadataType {
                 const originalKey = event[0][this.definition.keyField];
                 const eventDef = JSON.parse(
                     Util.replaceByObject(
-                        JSON.stringify(this.parseMetadata(event[0])),
+                        JSON.stringify(this.postRetrieveTasks(event[0])),
                         templateVariables
                     )
                 );
                 if (!eventDef.dataExtensionId) {
                     throw new Error(
-                        `Event.parseMetadata:: ` +
+                        `Event.postRetrieveTasks:: ` +
                             `No Data Extension found for ` +
                             `event: ${eventDef.name}. ` +
                             `This cannot be templated`
@@ -105,17 +129,6 @@ class Event extends MetadataType {
         }
     }
 
-    /**
-     * manages post retrieve steps
-     *
-     * @param {TYPE.MetadataTypeItem} eventDef a single item of Event Definition
-     * @returns {TYPE.MetadataTypeItem} metadata
-     */
-    static postRetrieveTasks(eventDef) {
-        const val = this.parseMetadata(eventDef);
-        this.keepRetrieveFields(val);
-        return val;
-    }
     /**
      * Delete a metadata item from the specified business unit
      *
@@ -133,10 +146,10 @@ class Event extends MetadataType {
     /**
      * Deploys metadata - merely kept here to be able to print {@link Util.logBeta} once per deploy
      *
-     * @param {TYPE.MetadataTypeMap} metadata metadata mapped by their keyField
+     * @param {MetadataTypeMap} metadata metadata mapped by their keyField
      * @param {string} deployDir directory where deploy metadata are saved
      * @param {string} retrieveDir directory where metadata after deploy should be saved
-     * @returns {Promise.<TYPE.MetadataTypeMap>} Promise of keyField => metadata map
+     * @returns {Promise.<MetadataTypeMap>} Promise of keyField => metadata map
      */
     static async deploy(metadata, deployDir, retrieveDir) {
         Util.logBeta(this.definition.type);
@@ -146,23 +159,23 @@ class Event extends MetadataType {
     /**
      * Creates a single Event Definition
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single Event Definition
+     * @param {MetadataTypeItem} metadata a single Event Definition
      * @returns {Promise} Promise
      */
     static create(metadata) {
-        return super.createREST(metadata, '/interaction/v1/EventDefinitions/');
+        return super.createREST(metadata, '/interaction/v1/eventDefinitions/');
     }
 
     /**
      * Updates a single Event Definition (using PUT method since PATCH isn't supported)
      *
-     * @param {TYPE.MetadataTypeItem} metadataEntry a single Event Definition
+     * @param {MetadataTypeItem} metadataEntry a single Event Definition
      * @returns {Promise} Promise
      */
     static async update(metadataEntry) {
         return super.updateREST(
             metadataEntry,
-            '/interaction/v1/EventDefinitions/' + metadataEntry.id,
+            '/interaction/v1/eventDefinitions/' + metadataEntry.id,
             'put'
         );
     }
@@ -170,45 +183,67 @@ class Event extends MetadataType {
     /**
      * prepares an event definition for deployment
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single eventDefinition
-     * @returns {TYPE.MetadataTypeItem} parsed version
+     * @param {MetadataTypeItem} metadata a single eventDefinition
+     * @returns {MetadataTypeItem} parsed version
      */
     static preDeployTasks(metadata) {
-        metadata.dataExtensionId = cache.searchForField(
-            'dataExtension',
-            metadata.dataExtensionName,
-            'Name',
-            'ObjectID'
-        );
-        metadata.arguments.dataExtensionId = metadata.dataExtensionId;
+        if (metadata.r__dataExtension_key) {
+            metadata.dataExtensionId = cache.searchForField(
+                'dataExtension',
+                metadata.r__dataExtension_key,
+                'CustomerKey',
+                'ObjectID'
+            );
+            metadata.dataExtensionName = cache.searchForField(
+                'dataExtension',
+                metadata.r__dataExtension_key,
+                'CustomerKey',
+                'Name'
+            );
+            metadata.arguments.dataExtensionId = metadata.dataExtensionId;
+            if (metadata.schema) {
+                metadata.schema.id = metadata.dataExtensionId;
+                metadata.schema.name = metadata.dataExtensionName;
+            }
+        }
+        metadata.arguments.eventDefinitionKey = metadata.eventDefinitionKey;
+
+        // standard values
+        metadata.isVisibleInPicker ||= false;
+        metadata.isPlatformObject = false;
+        metadata.mode = 'Production'; // potentially needs to be set to "1" instead
         return metadata;
     }
 
     /**
      * parses retrieved Metadata before saving
      *
-     * @param {TYPE.MetadataTypeItem} metadata a single event definition
-     * @returns {TYPE.MetadataTypeItem} parsed metadata
+     * @param {MetadataTypeItem} metadata a single event definition
+     * @returns {MetadataTypeItem} parsed metadata
      */
-    static parseMetadata(metadata) {
+    static postRetrieveTasks(metadata) {
         try {
-            metadata.dataExtensionId = cache.searchForField(
+            metadata.r__dataExtension_key = cache.searchForField(
                 'dataExtension',
                 metadata.dataExtensionId,
                 'ObjectID',
                 'CustomerKey'
             );
-            metadata.arguments.dataExtensionId = metadata.dataExtensionId;
-            return JSON.parse(JSON.stringify(metadata));
-        } catch {
-            Util.metadataLogger(
-                'verbose',
-                this.definition.type,
-                'parseMetadata',
-                `No related Data Extension found for Event '${metadata.name}'. Consider deleting the event definition`
+            delete metadata.dataExtensionId;
+            delete metadata.dataExtensionName;
+            delete metadata.arguments.dataExtensionId;
+            if (metadata.schema) {
+                delete metadata.schema.id;
+                delete metadata.schema.name;
+            }
+        } catch (ex) {
+            Util.logger.verbose(
+                ` - ${this.definition.type} ${metadata[this.definition.nameField]} (${
+                    metadata[this.definition.keyField]
+                }): ${ex.message}.`
             );
-            return metadata;
         }
+        return metadata;
     }
 }
 

package/lib/metadataTypes/FileLocation.js

@@ -1,8 +1,20 @@
 'use strict';
 
-import TYPE from '../../types/mcdev.d.js';
 import MetadataType from './MetadataType.js';
 
+/**
+ * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
+ * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
+ * @typedef {import('../../types/mcdev.d.js').CodeExtractItem} CodeExtractItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItem} MetadataTypeItem
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemDiff} MetadataTypeItemDiff
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeItemObj} MetadataTypeItemObj
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMap} MetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
+ * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
+ * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ */
+
 /**
  * ImportFile MetadataType
  *
@@ -14,10 +26,10 @@ class FtpLocation extends MetadataType {
      * Endpoint /automation/v1/ftplocations/ return all FtpLocations
      *
      * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
-     * @param {void} [_] unused parameter
-     * @param {void} [__] unused parameter
+     * @param {void | string[]} [_] unused parameter
+     * @param {void | string[]} [__] unused parameter
      * @param {string} [key] customer key of single item to retrieve
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static retrieve(retrieveDir, _, __, key) {
         return super.retrieveREST(retrieveDir, '/automation/v1/ftplocations/', null, key);
@@ -26,7 +38,7 @@ class FtpLocation extends MetadataType {
     /**
      * Retrieves folder metadata into local filesystem. Also creates a uniquePath attribute for each folder.
      *
-     * @returns {Promise.<TYPE.MetadataTypeMapObj>} Promise
+     * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieveForCache() {
         return super.retrieveREST(null, '/automation/v1/ftplocations/');