mcdev 8.3.1 → 8.4.0

package/lib/metadataTypes/DataFilter.js

@@ -110,8 +110,10 @@ class DataFilter extends MetadataType {
      */
     static async _getFilterFolderIds(recached = false) {
         const fromCache =
-            this.cache.folderFilter || cache.getCache().folder
-                ? Object.values(this.cache.folderFilter || cache.getCache().folder)
+            this.cache[this.buObject.mid]?.folderFilter || cache.getCache().folder
+                ? Object.values(
+                      this.cache[this.buObject.mid]?.folderFilter || cache.getCache().folder
+                  )
                       .filter((item) => item.ContentType === 'filterdefinition')
                       .filter(
                           (item) =>
@@ -135,7 +137,10 @@ class DataFilter extends MetadataType {
         Folder.client = this.client;
         Folder.buObject = this.buObject;
         Folder.properties = this.properties;
-        this.cache.folderFilter = (await Folder.retrieveForCache(null, subTypeArr)).metadata;
+        this.cache[this.buObject.mid] ||= {};
+        this.cache[this.buObject.mid].folderFilter = (
+            await Folder.retrieveForCache(null, subTypeArr)
+        ).metadata;
         return this._getFilterFolderIds(true);
     }
     /**
@@ -145,9 +150,9 @@ class DataFilter extends MetadataType {
      */
     static async _getMeasureFolderIds() {
         const fromCache =
-            this.cache.folderMeasure?.[this.buObject.mid] || cache.getCache().folder
+            this.cache[this.buObject.mid]?.folderMeasure || cache.getCache().folder
                 ? Object.values(
-                      this.cache.folderMeasure?.[this.buObject.mid] || cache.getCache().folder
+                      this.cache[this.buObject.mid]?.folderMeasure || cache.getCache().folder
                   )
                       .filter((item) => item.ContentType === 'measure')
                       .map((item) => item.ID)
@@ -163,8 +168,9 @@ class DataFilter extends MetadataType {
         Folder.client = this.client;
         Folder.buObject = this.buObject;
         Folder.properties = this.properties;
-        this.cache.folderMeasure ||= {};
-        this.cache.folderMeasure[this.buObject.mid] = (
+        this.cache[this.buObject.mid] ||= {};
+        this.cache[this.buObject.mid].folderMeasure ||= {};
+        this.cache[this.buObject.mid].folderMeasure = (
             await Folder.retrieveForCache(null, subTypeArr)
         ).metadata;
         return this._getMeasureFolderIds();
@@ -205,8 +211,8 @@ class DataFilter extends MetadataType {
                       .map((item) => item.r__source_dataExtension_key)
                       .filter(
                           (deKey) =>
-                              !this.cache.dataExtensionField ||
-                              !this.cache.dataExtensionField[deKey]
+                              !this.cache[this.buObject.mid]?.dataExtensionField ||
+                              !this.cache[this.buObject.mid]?.dataExtensionField[deKey]
                       )
                       .filter(Boolean);
         if (deKeys.length) {
@@ -246,7 +252,8 @@ class DataFilter extends MetadataType {
      * @param {DataExtensionFieldMap} deFieldCache -
      */
     static saveDataExtensionFieldCacheToMap(deFieldCache) {
-        this.cache.dataExtensionField ||= {};
+        this.cache[this.buObject.mid] ||= {};
+        this.cache[this.buObject.mid].dataExtensionField ||= {};
 
         if (!deFieldCache) {
             return;
@@ -255,11 +262,16 @@ class DataFilter extends MetadataType {
             if (!field?.DataExtension?.CustomerKey) {
                 continue;
             }
-            if (!this.cache.dataExtensionField[field.DataExtension.CustomerKey]) {
+            if (
+                !this.cache[this.buObject.mid].dataExtensionField[field.DataExtension.CustomerKey]
+            ) {
                 /** @type {Object.<string, DataExtensionFieldItem[]>} */
-                this.cache.dataExtensionField[field.DataExtension.CustomerKey] = [];
+                this.cache[this.buObject.mid].dataExtensionField[field.DataExtension.CustomerKey] =
+                    [];
             }
-            this.cache.dataExtensionField[field.DataExtension.CustomerKey].push(field);
+            this.cache[this.buObject.mid].dataExtensionField[field.DataExtension.CustomerKey].push(
+                field
+            );
         }
     }
     /**
@@ -268,7 +280,7 @@ class DataFilter extends MetadataType {
      * @param {DataFilterMap} metadataTypeMap -
      */
     static async _cacheContactAttributes(metadataTypeMap) {
-        if (this.cache.contactAttributes?.[this.buObject.mid]) {
+        if (this.cache[this.buObject.mid]?.contactAttributes) {
             return;
         }
         const subscriberFilters = Object.values(metadataTypeMap)
@@ -279,8 +291,8 @@ class DataFilter extends MetadataType {
             const response = await this.client.rest.get('/email/v1/Contacts/Attributes/');
             const keyFieldBackup = this.definition.keyField;
             this.definition.keyField = 'id';
-            this.cache.contactAttributes ||= {};
-            this.cache.contactAttributes[this.buObject.mid] = this.parseResponseBody(response);
+            this.cache[this.buObject.mid] ||= {};
+            this.cache[this.buObject.mid].contactAttributes = this.parseResponseBody(response);
             this.definition.keyField = keyFieldBackup;
         }
     }
@@ -290,7 +302,7 @@ class DataFilter extends MetadataType {
      * @param {DataFilterMap} metadataTypeMap -
      */
     static async _cacheMeasures(metadataTypeMap) {
-        if (this.cache.measures?.[this.buObject.mid]) {
+        if (this.cache?.[this.buObject.mid]?.measures) {
             return;
         }
         const subscriberFilters = Object.values(metadataTypeMap)
@@ -312,8 +324,8 @@ class DataFilter extends MetadataType {
 
             const keyFieldBackup = this.definition.keyField;
             this.definition.keyField = 'measureID';
-            this.cache.measures ||= {};
-            this.cache.measures[this.buObject.mid] = this.parseResponseBody(response);
+            this.cache[this.buObject.mid] ||= {};
+            this.cache[this.buObject.mid].measures = this.parseResponseBody(response);
             this.definition.keyField = keyFieldBackup;
         }
     }
@@ -439,7 +451,9 @@ class DataFilter extends MetadataType {
             return this._resolveFields(
                 metadata,
                 mode,
-                this.cache.dataExtensionField[metadata.r__source_dataExtension_key],
+                this.cache[this.buObject.mid].dataExtensionField[
+                    metadata.r__source_dataExtension_key
+                ],
                 metadata.c__filterDefinition?.ConditionSet
             );
         }
@@ -530,8 +544,8 @@ class DataFilter extends MetadataType {
                 metadata.c__filterDefinition?.ConditionSet
             );
         }
-        const contactAttributes = this.cache.contactAttributes[this.buObject.mid];
-        const measures = this.cache.measures[this.buObject.mid];
+        const contactAttributes = this.cache[this.buObject.mid]?.contactAttributes;
+        const measures = this.cache[this.buObject.mid]?.measures;
         const conditionsArr = Array.isArray(filter.Condition)
             ? filter.Condition
             : [filter.Condition];

package/lib/metadataTypes/Event.js

@@ -1067,7 +1067,7 @@ class Event extends MetadataType {
             if (errors.length > 1) {
                 errors.unshift(``);
             }
-            throw new Error(errors.join('\n        · ')); // eslint-disable-line unicorn/error-message
+            throw new Error(errors.join('\n        · '));
         }
         if (warnings?.length) {
             // add a line break
@@ -1220,7 +1220,7 @@ class Event extends MetadataType {
             if (errors.length > 1) {
                 errors.unshift(``);
             }
-            throw new Error(errors.join('\n        · ')); // eslint-disable-line unicorn/error-message
+            throw new Error(errors.join('\n        · '));
         }
     }
 

package/lib/metadataTypes/FileLocation.js

@@ -22,6 +22,7 @@ import { Util } from '../util/util.js';
  * @augments MetadataType
  */
 class FileLocation extends MetadataType {
+    static cache = {};
     /**
      * Retrieves Metadata of FileLocation
      * Endpoint /automation/v1/ftplocations/ return all FileLocations
@@ -32,8 +33,32 @@ class FileLocation extends MetadataType {
      * @param {string} [key] customer key of single item to retrieve
      * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
-    static retrieve(retrieveDir, _, __, key) {
-        return super.retrieveREST(retrieveDir, '/automation/v1/ftplocations/', null, key);
+    static async retrieve(retrieveDir, _, __, key) {
+        try {
+            const dataItems = await super.retrieveREST(
+                null,
+                '/data/v1/filetransferlocation' + (key ? '/' + encodeURIComponent(key) : 's'),
+                null,
+                key
+            );
+            this.cache[this.buObject.mid] ||= {};
+            this.cache[this.buObject.mid].dataItems = dataItems.metadata;
+        } catch (ex) {
+            if (ex.code === 'ERR_BAD_REQUEST') {
+                // if retrieve-by-key comes up empty, the data-endpoint returns a code 400
+                Util.logger.debug(ex.message);
+            } else {
+                Util.logger.warn(ex.message);
+            }
+        }
+        const items = await super.retrieveREST(
+            retrieveDir,
+            '/automation/v1/ftplocations/',
+            null,
+            key
+        );
+
+        return items;
     }
 
     /**
@@ -42,9 +67,156 @@ class FileLocation extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static async retrieveForCache() {
-        return super.retrieveREST(null, '/automation/v1/ftplocations/');
+        return this.retrieve(null);
+    }
+
+    /**
+     * Creates a single item
+     *
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {Promise.<MetadataTypeItem>} Promise
+     */
+    static create(metadata) {
+        return this.createREST(metadata, '/data/v1/filetransferlocation');
+    }
+    /**
+     * Updates a single item
+     *
+     * @param {MetadataTypeItem} metadata a single item
+     * @returns {Promise.<MetadataTypeItem>} Promise
+     */
+    static update(metadata) {
+        return this.updateREST(
+            metadata,
+            '/data/v1/filetransferlocation/' +
+                encodeURIComponent(metadata[this.definition.keyField])
+        );
     }
 
+    /**
+     * helper for {@link MetadataType.parseResponseBody} that creates a custom key field for this type based on mobileCode and keyword
+     *
+     * @param {MetadataTypeItem} metadata single item
+     */
+    static createCustomKeyField(metadata) {
+        if (metadata.fileTransferLocation) {
+            const fileTransferLocation = metadata.fileTransferLocation;
+            for (const key of Object.keys(metadata)) {
+                delete metadata[key];
+            }
+            Object.assign(metadata, fileTransferLocation);
+        } else {
+            if (!metadata.customerKey && this.cache[this.buObject.mid]?.dataItems) {
+                const nameMatch = Object.values(this.cache[this.buObject.mid].dataItems).find(
+                    (item) => item.name === metadata.name
+                );
+                if (nameMatch) {
+                    Object.assign(metadata, nameMatch);
+                }
+            }
+            if (!this.definition.locationTypeIdMappingDeployable[metadata.locationTypeId]) {
+                // old file location types are only returned by the automation-endpoint which does not return customerKey field - but also these are not updatable and hence we can improvise here
+
+                metadata.customerKey ||= metadata.name;
+            }
+        }
+    }
+
+    /**
+     * Creates a single metadata entry via REST
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {string} uri rest endpoint for POST
+     * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
+     */
+    static async createREST(metadataEntry, uri, handleOutside) {
+        this.removeNotCreateableFields(metadataEntry);
+        const createPayload = { fileTransferLocation: metadataEntry };
+        try {
+            // set to empty object in case API returned nothing to be able to update it in helper classes
+            let response = (await this.client.rest.post(uri, createPayload)) || {};
+            response = await this.postCreateTasks(metadataEntry, response);
+            if (!handleOutside) {
+                Util.logger.info(
+                    ` - created ${Util.getTypeKeyName(this.definition, metadataEntry)}`
+                );
+            }
+            return response;
+        } catch (ex) {
+            const parsedErrors = this.getErrorsREST(ex);
+            Util.logger.error(
+                ` ☇ error creating ${Util.getTypeKeyName(this.definition, metadataEntry)}:`
+            );
+            if (parsedErrors.length) {
+                for (const msg of parsedErrors) {
+                    Util.logger.error('   • ' + msg);
+                }
+            } else if (ex?.message) {
+                Util.logger.debug(ex.message);
+            }
+            return null;
+        }
+    }
+
+    /**
+     * helper for {@link MetadataType.createREST}
+     *
+     * @param {MetadataTypeItem} _ a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<object>} apiResponse, potentially modified
+     */
+    static async postCreateTasks(_, apiResponse) {
+        return apiResponse?.fileTransferLocation || apiResponse;
+    }
+
+    /**
+     * Updates a single metadata entry via REST
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {string} uri rest endpoint for PATCH
+     * @param {'patch'|'post'|'put'} [httpMethod] defaults to 'patch'; some update requests require PUT instead of PATCH
+     * @param {boolean} [handleOutside] if the API reponse is irregular this allows you to handle it outside of this generic method
+     * @returns {Promise.<object> | null} Promise of API response or null in case of an error
+     */
+    static async updateREST(metadataEntry, uri, httpMethod = 'patch', handleOutside) {
+        this.removeNotUpdateableFields(metadataEntry);
+        const updatePayload = { fileTransferLocation: metadataEntry };
+        try {
+            // set to empty object in case API returned nothing to be able to update it in helper classes
+            let response = (await this.client.rest[httpMethod](uri, updatePayload)) || {};
+            await this._postChangeKeyTasks(metadataEntry);
+            this.getErrorsREST(response);
+            response = await this.postUpdateTasks(metadataEntry, response);
+            // some times, e.g. automation dont return a key in their update response and hence we need to fall back to name
+            if (!handleOutside) {
+                Util.logger.info(
+                    ` - updated ${Util.getTypeKeyName(this.definition, metadataEntry)}`
+                );
+            }
+            return response;
+        } catch (ex) {
+            const parsedErrors = this.getErrorsREST(ex);
+            Util.logger.error(
+                ` ☇ error updating ${Util.getTypeKeyName(this.definition, metadataEntry)}:`
+            );
+            for (const msg of parsedErrors) {
+                Util.logger.error('   • ' + msg);
+            }
+            return null;
+        }
+    }
+
+    /**
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP}
+     *
+     * @param {MetadataTypeItem} _ a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<object>} apiResponse, potentially modified
+     */
+    static postUpdateTasks(_, apiResponse) {
+        return apiResponse?.fileTransferLocation || apiResponse;
+    }
     /**
      * prepares a import definition for deployment
      *
@@ -54,6 +226,14 @@ class FileLocation extends MetadataType {
     static async preDeployTasks(metadata) {
         if (metadata.c__locationType) {
             metadata.locationTypeId = this.definition.locationTypeMapping[metadata.c__locationType];
+            if (this.definition.locationTypeMappingDeployable[metadata.c__locationType]) {
+                metadata.locationType =
+                    this.definition.locationTypeMappingDeployable[metadata.c__locationType];
+            } else {
+                throw new Error(
+                    `Only FileLocations of types ${Object.keys(this.definition.locationTypeMappingDeployable).join(', ')} can be deployed via mcdev.`
+                );
+            }
         }
         return metadata;
     }
@@ -65,7 +245,7 @@ class FileLocation extends MetadataType {
      * @returns {MetadataTypeItem} parsed metadata
      */
     static postRetrieveTasks(metadata) {
-        if (metadata.locationTypeId) {
+        if (metadata.locationTypeId !== undefined) {
             try {
                 metadata.c__locationType = Util.inverseGet(
                     this.definition.locationTypeMapping,
@@ -78,9 +258,29 @@ class FileLocation extends MetadataType {
                         metadata.locationTypeId
                 );
             }
+        } else if (metadata.locationType) {
+            // assuming create/update of new types
+            metadata.c__locationType = Util.inverseGet(
+                this.definition.locationTypeMappingDeployable,
+                metadata.locationType
+            );
         }
         return metadata;
     }
+
+    /**
+     * Delete a metadata item from the specified business unit
+     *
+     * @param {string} key Identifier of item
+     * @returns {Promise.<boolean>} deletion success flag
+     */
+    static async deleteByKey(key) {
+        return super.deleteByKeyREST(
+            '/data/v1/filetransferlocation/' + encodeURIComponent(key),
+            key,
+            400
+        );
+    }
 }
 
 // Assign definition to static attributes

package/lib/metadataTypes/Journey.js

@@ -50,6 +50,11 @@ class Journey extends MetadataType {
 
         let singleKey = '';
         let mode = 'all';
+        const additionalParams = new URLSearchParams();
+        if (Util.OPTIONS.onlyPublished) {
+            Util.logger.info(' - Retrieving only published versions of journeys');
+            additionalParams.set('status', 'Published');
+        }
         if (key) {
             if (key.startsWith('%23')) {
                 // correct the format
@@ -74,7 +79,7 @@ class Journey extends MetadataType {
                 }
                 mode = 'id';
             } else if (key.startsWith('name:')) {
-                singleKey = '?nameOrDescription=' + encodeURIComponent(key.slice(5));
+                additionalParams.set('nameOrDescription', key.slice(5));
                 mode = 'name';
             } else {
                 // assume actual key was provided
@@ -85,7 +90,10 @@ class Journey extends MetadataType {
 
         try {
             const uri = `/interaction/v1/interactions/`;
-            if ((singleKey && (mode === 'key' || mode === 'id')) || !retrieveDir) {
+            if (
+                (!Util.OPTIONS.onlyPublished && singleKey && (mode === 'key' || mode === 'id')) ||
+                !retrieveDir
+            ) {
                 // full details for retrieve, only base data for caching; reduces caching time from minutes to seconds
                 const extras = retrieveDir && singleKey ? extrasDefault : '';
 
@@ -97,13 +105,12 @@ class Journey extends MetadataType {
                     key
                 );
             } else {
+                const url =
+                    uri + (additionalParams.size > 0 ? '?' + additionalParams.toString() : '');
                 // retrieve all
                 const results = this.definition.restPagination
-                    ? await this.client.rest.getBulk(
-                          uri + (mode === 'name' ? singleKey : ''),
-                          this.definition.restPageSize || 500
-                      )
-                    : await this.client.rest.get(uri + (mode === 'name' ? singleKey : ''));
+                    ? await this.client.rest.getBulk(url, this.definition.restPageSize || 500)
+                    : await this.client.rest.get(url);
 
                 if (results.items?.length) {
                     // empty results will come back without "items" defined
@@ -115,51 +122,71 @@ class Journey extends MetadataType {
                 }
                 // full details for retrieve
                 const extras = extrasDefault;
+                let details = [];
                 let parsed;
                 if (retrieveDir) {
                     const searchName = mode === 'name' ? key.slice(5) : null;
                     const foundKey = [];
+                    let journey;
                     // get extra details for saving this
-                    const details = results.items
-                        ? await Promise.all(
-                              results.items.map(async (a) => {
-                                  if (mode === 'name') {
-                                      // when filtering by name, the API in fact does a LIKE search with placeholders left and right of the search term - and also searches the description field.
-                                      if (searchName === a[this.definition.nameField]) {
-                                          foundKey.push(a[this.definition.keyField]);
-                                      } else {
-                                          // skip because the name does not match
+                    if (Util.OPTIONS.onlyPublished && mode === 'key') {
+                        journey = results.items.find(
+                            (a) => a[this.definition.keyField] === singleKey.slice(4)
+                        );
+                    } else if (Util.OPTIONS.onlyPublished && mode === 'id') {
+                        journey = results.items.find(
+                            (a) => a[this.definition.idField] === singleKey
+                        );
+                    } else {
+                        details = results.items
+                            ? await Promise.all(
+                                  results.items.map(async (a) => {
+                                      if (mode === 'name') {
+                                          // when filtering by name, the API in fact does a LIKE search with placeholders left and right of the search term - and also searches the description field.
+                                          if (searchName === a[this.definition.nameField]) {
+                                              foundKey.push(a[this.definition.keyField]);
+                                          } else {
+                                              // skip because the name does not match
+                                              return null;
+                                          }
+                                      }
+                                      try {
+                                          return await this.client.rest.get(
+                                              `${uri}key:${a[this.definition.keyField]}?extras=${extras}` +
+                                                  `&versionNumber=${a.version}`
+                                          );
+                                      } catch (ex) {
+                                          // if we do get here, we should log the error and continue instead of failing to download all automations
+                                          Util.logger.warn(
+                                              ` ☇ skipping ${this.definition.type} ${
+                                                  a[this.definition.nameField]
+                                              } (${a[this.definition.keyField]}): ${ex.message} (${
+                                                  ex.code
+                                              })${
+                                                  ex.endpoint
+                                                      ? Util.getGrayMsg(
+                                                            ' - ' +
+                                                                ex.endpoint.split(
+                                                                    'rest.marketingcloudapis.com'
+                                                                )[1]
+                                                        )
+                                                      : ''
+                                              }`
+                                          );
                                           return null;
                                       }
-                                  }
-                                  try {
-                                      return await this.client.rest.get(
-                                          `${uri}key:${a[this.definition.keyField]}?extras=${extras}` +
-                                              `&versionNumber=${a.version}`
-                                      );
-                                  } catch (ex) {
-                                      // if we do get here, we should log the error and continue instead of failing to download all automations
-                                      Util.logger.warn(
-                                          ` ☇ skipping ${this.definition.type} ${
-                                              a[this.definition.nameField]
-                                          } (${a[this.definition.keyField]}): ${ex.message} (${
-                                              ex.code
-                                          })${
-                                              ex.endpoint
-                                                  ? Util.getGrayMsg(
-                                                        ' - ' +
-                                                            ex.endpoint.split(
-                                                                'rest.marketingcloudapis.com'
-                                                            )[1]
-                                                    )
-                                                  : ''
-                                          }`
-                                      );
-                                      return null;
-                                  }
-                              })
-                          )
-                        : [];
+                                  })
+                              )
+                            : [];
+                    }
+                    if (Util.OPTIONS.onlyPublished && journey) {
+                        details.push(
+                            await this.client.rest.get(
+                                `${uri}${singleKey}?extras=${extras}` +
+                                    `&versionNumber=${journey.version}`
+                            )
+                        );
+                    }
                     parsed = this.parseResponseBody({ items: details.filter(Boolean) });
                     // * retrieveDir is mandatory in this method as it is not used for caching (there is a seperate method for that)
                     const savedMetadata = await this.saveResults(parsed, retrieveDir, null, null);

package/lib/metadataTypes/Script.js

@@ -83,6 +83,22 @@ class Script extends MetadataType {
         return super.updateREST(script, '/automation/v1/scripts/' + script.ssjsActivityId);
     }
 
+    /**
+     * helper for {@link MetadataType.updateREST} and {@link MetadataType.updateSOAP}
+     *
+     * @param {MetadataTypeItem} metadataEntry a single metadata Entry
+     * @param {object} apiResponse varies depending on the API call
+     * @returns {Promise.<object>} apiResponse, potentially modified
+     */
+    static async postUpdateTasks(metadataEntry, apiResponse) {
+        // script update endpoint returns wrong values for createdDate and modifiedDate - need to re-retrieve to get correct values
+        const ssjsActivityId = apiResponse?.ssjsActivityId;
+        if (ssjsActivityId) {
+            apiResponse = await this.client.rest.get('/automation/v1/scripts/' + ssjsActivityId);
+        }
+        return apiResponse;
+    }
+
     /**
      * Creates a single Script
      *

package/lib/metadataTypes/definitions/DataFilter.definition.js

@@ -23,6 +23,7 @@ export default {
     soapType: 'FilterDefinition',
     typeDescription: 'Defines an audience based on specified rules. Used by Filter Activities.',
     typeRetrieveByDefault: true,
+    typeCdpByDefault: true,
     typeName: 'Data Filter',
     fields: {
         // the GUI seems to ONLY send fields during update that are actually changed. It has yet to be tested if that also works with sending other fiedls as well

package/lib/metadataTypes/definitions/DataFilterHidden.definition.js

@@ -24,6 +24,7 @@ export default {
     typeDescription:
         'Defines an audience based on specified rules. Auto-generated by filtered DEs and filtered Lists.',
     typeRetrieveByDefault: false,
+    typeCdpByDefault: false,
     typeName: 'Data Filter (auto-generated)',
     fields: {
         // the GUI seems to ONLY send fields during update that are actually changed. It has yet to be tested if that also works with sending other fiedls as well