mcdev 8.2.0 → 8.3.0

package/@types/lib/metadataTypes/Filter.d.ts

@@ -9,6 +9,7 @@ export type MetadataTypeMap = import("../../types/mcdev.d.js").MetadataTypeMap;
 export type MetadataTypeMapObj = import("../../types/mcdev.d.js").MetadataTypeMapObj;
 export type SoapRequestParams = import("../../types/mcdev.d.js").SoapRequestParams;
 export type TemplateMap = import("../../types/mcdev.d.js").TemplateMap;
+export type FilterItem = import("../../types/mcdev.d.js").FilterItem;
 /**
  * @typedef {import('../../types/mcdev.d.js').BuObject} BuObject
  * @typedef {import('../../types/mcdev.d.js').CodeExtract} CodeExtract
@@ -20,6 +21,7 @@ export type TemplateMap = import("../../types/mcdev.d.js").TemplateMap;
  * @typedef {import('../../types/mcdev.d.js').MetadataTypeMapObj} MetadataTypeMapObj
  * @typedef {import('../../types/mcdev.d.js').SoapRequestParams} SoapRequestParams
  * @typedef {import('../../types/mcdev.d.js').TemplateMap} TemplateMap
+ * @typedef {import('../../types/mcdev.d.js').FilterItem} FilterItem
  */
 /**
  * Filter MetadataType
@@ -40,17 +42,92 @@ declare class Filter extends MetadataType {
      * @returns {Promise.<MetadataTypeMapObj>} Promise
      */
     static retrieve(retrieveDir: string, _?: void | string[], __?: void | string[], key?: string): Promise<MetadataTypeMapObj>;
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {FilterItem} metadata a single record
+     * @returns {FilterItem} parsed metadata definition
+     */
+    static postRetrieveTasks(metadata: FilterItem): FilterItem;
+    /**
+     * helper for postRetrieveTasks to map data types
+     *
+     * @param {'source'|'destination'} target we are processing source and destinations
+     * @param {FilterItem} metadata single record
+     */
+    static _postRetrieve_dataTypeMapping(target: "source" | "destination", metadata: FilterItem): void;
+    /**
+     * helper for preDeployTasks to map data types
+     *
+     * @param {'source'|'destination'} target we are processing source and destinations
+     * @param {FilterItem} metadata single record
+     * @param {FilterItem} cachedVersion cached version of the metadata
+     */
+    static _preDeploy_dataTypeMapping(target: "source" | "destination", metadata: FilterItem, cachedVersion: FilterItem): void;
+    /**
+     * Creates a single item
+     * this uses soap API because the rest api does not allow hotlinking to an existing target DE
+     *
+     * @param {FilterItem} item a single item
+     * @returns {Promise} Promise
+     */
+    static create(item: FilterItem): Promise<any>;
+    /**
+     * helper that converts the rest item into a soap item
+     *
+     * @param {FilterItem} item a single item
+     * @returns {object} SOAP formatted filter item
+     */
+    static preCreateSOAPItem(item: FilterItem): object;
+    /**
+     * helper that runs update on all create calls to ensure all fields are set
+     *
+     * @param {FilterItem} restItem original rest item
+     * @param {object} response SOAP response
+     * @returns {Promise.<FilterItem>} created item
+     */
+    static postCreateTasks(restItem: FilterItem, response: object): Promise<FilterItem>;
+    /**
+     * Updates a single item
+     *
+     * @param {MetadataTypeItem} item a single item
+     * @returns {Promise} Promise
+     */
+    static update(item: MetadataTypeItem): Promise<any>;
+    /**
+     * prepares a record for deployment
+     *
+     * @param {FilterItem} metadata a single record
+     * @returns {Promise.<FilterItem>} Promise of updated single record
+     */
+    static preDeployTasks(metadata: FilterItem): Promise<FilterItem>;
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or empty string
+     */
+    private static _getObjectIdForSingleRetrieve;
 }
 declare namespace Filter {
     let definition: {
         bodyIteratorField: string;
-        dependencies: any[];
-        dependencyGraph: any;
+        dependencies: string[];
+        dependencyGraph: {
+            filterDefinition: string[];
+            dataExtension: string[];
+        };
         hasExtended: boolean;
         idField: string;
         keyIsFixed: boolean;
         keyField: string;
         nameField: string;
+        folderType: string;
+        folderIdField: string;
+        filter: {
+            statusId: number;
+        };
         createdDateField: string;
         createdNameField: any;
         lastmodDateField: string;
@@ -58,6 +135,7 @@ declare namespace Filter {
         restPagination: boolean;
         maxKeyLength: number;
         type: string;
+        soapType: string;
         typeDescription: string;
         typeRetrieveByDefault: boolean;
         typeCdpByDefault: boolean;
@@ -76,7 +154,13 @@ declare namespace Filter {
                 template: boolean;
             };
             customerKey: {
-                isCreateable: any;
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            CustomerKey: {
+                isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
@@ -87,22 +171,41 @@ declare namespace Filter {
                 retrieving: boolean;
                 template: boolean;
             };
+            Description: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             destinationObjectId: {
                 isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
             };
+            DestinationObjectID: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             destinationTypeId: {
                 isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
             };
+            DestinationTypeID: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             filterActivityId: {
-                isCreateable: any;
-                isUpdateable: any;
+                isCreateable: boolean;
+                isUpdateable: boolean;
                 retrieving: boolean;
+                template: boolean;
             };
             filterDefinitionId: {
                 isCreateable: boolean;
@@ -110,6 +213,12 @@ declare namespace Filter {
                 retrieving: boolean;
                 template: boolean;
             };
+            FilterDefinitionID: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             modifiedDate: {
                 isCreateable: boolean;
                 isUpdateable: boolean;
@@ -117,7 +226,13 @@ declare namespace Filter {
                 template: boolean;
             };
             name: {
-                isCreateable: any;
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            Name: {
+                isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
@@ -128,18 +243,78 @@ declare namespace Filter {
                 retrieving: boolean;
                 template: boolean;
             };
+            SourceObjectID: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             sourceTypeId: {
                 isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
             };
+            SourceTypeID: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            filterDefinitionSourceTypeId: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
             statusId: {
                 isCreateable: boolean;
                 isUpdateable: boolean;
                 retrieving: boolean;
                 template: boolean;
             };
+            resultDEName: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            resultDEKey: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            resultDEDescription: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            r__folder_Path: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            r__dataFilter_key: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            r__source_dataExtension_key: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            r__destination_dataExtension_key: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
         };
     };
 }

package/@types/lib/metadataTypes/Filter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Filter.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Filter.js"],"names":[],"mappings":";uBAKa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;AAVzD;;;;;;;;;;;GAWG;AAEH;;;;GAIG;AACH;IACI;;;;;;;;;;;OAWG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,OACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CAIxC;CACJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBApCwB,mBAAmB"}
+{"version":3,"file":"Filter.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/Filter.js"],"names":[],"mappings":";uBAea,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;yBAC5C,OAAO,wBAAwB,EAAE,UAAU;AAXxD;;;;;;;;;;;;GAYG;AAEH;;;;GAIG;AACH;IACI;;;;;;;;;;;OAWG;IACH,6BANW,MAAM,MACN,IAAI,GAAG,MAAM,EAAE,OACf,IAAI,GAAG,MAAM,EAAE,QACf,MAAM,GACJ,OAAO,CAAE,kBAAkB,CAAC,CAKxC;IACD;;;;;OAKG;IACH,mCAHW,UAAU,GACR,UAAU,CAoCtB;IAED;;;;;OAKG;IACH,6CAHW,QAAQ,GAAC,aAAa,YACtB,UAAU,QA4CpB;IACD;;;;;;OAMG;IACH,0CAJW,QAAQ,GAAC,aAAa,YACtB,UAAU,iBACV,UAAU,QA8CpB;IAED;;;;;;OAMG;IACH,oBAHW,UAAU,gBAiBpB;IAED;;;;;OAKG;IACH,+BAHW,UAAU,GACR,MAAM,CAclB;IAED;;;;;;OAMG;IACH,iCAJW,UAAU,YACV,MAAM,GACJ,OAAO,CAAE,UAAU,CAAC,CAiBhC;IAED;;;;;OAKG;IACH,oBAHW,gBAAgB,gBAK1B;IAED;;;;;OAKG;IACH,gCAHW,UAAU,GACR,OAAO,CAAE,UAAU,CAAC,CAyChC;IAED;;;;;;OAMG;IACH,6CAUC;CAiBJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA9VwB,mBAAmB"}

package/@types/lib/metadataTypes/FilterDefinition.d.ts

@@ -0,0 +1,318 @@
+export default FilterDefinition;
+export type BuObject = import("../../types/mcdev.d.js").BuObject;
+export type CodeExtract = import("../../types/mcdev.d.js").CodeExtract;
+export type CodeExtractItem = import("../../types/mcdev.d.js").CodeExtractItem;
+export type MetadataTypeItem = import("../../types/mcdev.d.js").MetadataTypeItem;
+export type MetadataTypeItemDiff = import("../../types/mcdev.d.js").MetadataTypeItemDiff;
+export type MetadataTypeItemObj = import("../../types/mcdev.d.js").MetadataTypeItemObj;
+export type MetadataTypeMap = import("../../types/mcdev.d.js").MetadataTypeMap;
+export type MetadataTypeMapObj = import("../../types/mcdev.d.js").MetadataTypeMapObj;
+export type SoapRequestParams = import("../../types/mcdev.d.js").SoapRequestParams;
+export type TemplateMap = import("../../types/mcdev.d.js").TemplateMap;
+export type FilterDefinitionItem = import("../../types/mcdev.d.js").FilterDefinitionItem;
+export type FilterDefinitionMap = import("../../types/mcdev.d.js").FilterDefinitionMap;
+export type MultiMetadataTypeMap = import("../../types/mcdev.d.js").MultiMetadataTypeMap;
+export type FilterConditionSet = import("../../types/mcdev.d.js").FilterConditionSet;
+export type FilterCondition = import("../../types/mcdev.d.js").FilterCondition;
+/**
+ * @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
+ * @typedef {import('../../types/mcdev.d.js').FilterDefinitionItem} FilterDefinitionItem
+ * @typedef {import('../../types/mcdev.d.js').FilterDefinitionMap} FilterDefinitionMap
+ * @typedef {import('../../types/mcdev.d.js').MultiMetadataTypeMap} MultiMetadataTypeMap
+ * @typedef {import('../../types/mcdev.d.js').FilterConditionSet} FilterConditionSet
+ * @typedef {import('../../types/mcdev.d.js').FilterCondition} FilterCondition
+ */
+/**
+ * FilterDefinition MetadataType
+ *
+ * @augments MetadataType
+ */
+declare class FilterDefinition extends MetadataType {
+    static cache: {};
+    static deIdKeyMap: any;
+    static hidden: boolean;
+    /**
+     * Retrieves all records and saves it to disk
+     *
+     * @param {string} retrieveDir Directory where retrieved metadata directory will be saved
+     * @param {string[]} [_] unused parameter
+     * @param {string[]} [__] unused parameter
+     * @param {string} [key] customer key of single item to retrieve
+     * @returns {Promise.<{metadata: FilterDefinitionMap, type: string}>} Promise of items
+     */
+    static retrieve(retrieveDir: string, _?: string[], __?: string[], key?: string): Promise<{
+        metadata: FilterDefinitionMap;
+        type: string;
+    }>;
+    /**
+     * helper for {@link FilterDefinition.retrieve}
+     *
+     * @param {boolean} [recached] indicates if this is a recursive call after cache refresh
+     * @returns {Promise.<number[]>} Array of folder IDs
+     */
+    static _getFilterFolderIds(recached?: boolean): Promise<number[]>;
+    /**
+     * helper for {@link FilterDefinition._cacheMeasures}
+     *
+     * @returns {Promise.<number[]>} Array of folder IDs
+     */
+    static _getMeasureFolderIds(): Promise<number[]>;
+    /**
+     * helper for {@link FilterDefinition.retrieve}. uses cached dataExtensions to resolve dataExtensionFields
+     *
+     * @param {FilterDefinitionMap} metadataTypeMap -
+     * @param {'retrieve'|'deploy'} [mode] -
+     */
+    static _cacheDeFields(metadataTypeMap: FilterDefinitionMap, mode?: "retrieve" | "deploy"): Promise<void>;
+    /**
+     * helper for {@link FilterDefinition.retrieve}
+     *
+     * @param {FilterDefinitionMap} metadataTypeMap -
+     */
+    static _cacheContactAttributes(metadataTypeMap: FilterDefinitionMap): Promise<void>;
+    /**
+     * helper for {@link FilterDefinition.retrieve}
+     *
+     * @param {FilterDefinitionMap} metadataTypeMap -
+     */
+    static _cacheMeasures(metadataTypeMap: FilterDefinitionMap): Promise<void>;
+    /**
+     * Retrieves all records for caching
+     *
+     * @returns {Promise.<{metadata: FilterDefinitionMap, type: string}>} Promise of items
+     */
+    static retrieveForCache(): Promise<{
+        metadata: FilterDefinitionMap;
+        type: string;
+    }>;
+    /**
+     * parses retrieved Metadata before saving
+     *
+     * @param {FilterDefinitionItem} metadata a single record
+     * @returns {Promise.<FilterDefinitionItem>} parsed metadata definition
+     */
+    static postRetrieveTasks(metadata: FilterDefinitionItem): Promise<FilterDefinitionItem>;
+    /**
+     * helper for {@link postRetrieveTasks}
+     *
+     * @param {FilterDefinitionItem} metadata -
+     * @param {'postRetrieve'|'preDeploy'} mode -
+     * @param {object[]} [fieldCache] -
+     * @param {FilterConditionSet} [filter] -
+     * @returns {void}
+     */
+    static _resolveFields(metadata: FilterDefinitionItem, mode: "postRetrieve" | "preDeploy", fieldCache?: object[], filter?: FilterConditionSet): void;
+    /**
+     * helper for {@link _resolveFields}
+     *
+     * @param {FilterCondition} condition -
+     * @param {object[]} fieldCache -
+     * @returns {void}
+     */
+    static _postRetrieve_resolveFieldIdsCondition(condition: FilterCondition, fieldCache: object[]): void;
+    /**
+     * helper for {@link _resolveFields}
+     *
+     * @param {FilterCondition} condition -
+     * @param {object[]} fieldCache -
+     * @returns {void}
+     */
+    static _preDeploy_resolveFieldNamesCondition(condition: FilterCondition, fieldCache: object[]): void;
+    /**
+     * helper for {@link postRetrieveTasks}
+     *
+     * @param {FilterDefinitionItem} metadata -
+     * @param {object} [filter] -
+     * @returns {void}
+     */
+    static _postRetrieve_resolveAttributeIds(metadata: FilterDefinitionItem, filter?: object): void;
+    /**
+     * prepares a item for deployment
+     *
+     * @param {FilterDefinitionItem} metadata a single record
+     * @returns {Promise.<FilterDefinitionItem>} Promise of updated single item
+     */
+    static preDeployTasks(metadata: FilterDefinitionItem): Promise<FilterDefinitionItem>;
+    /**
+     * Creates a single item
+     *
+     * @param {FilterDefinitionItem} metadata a single item
+     * @returns {Promise.<FilterDefinitionItem>} Promise
+     */
+    static create(metadata: FilterDefinitionItem): Promise<FilterDefinitionItem>;
+    /**
+     * Updates a single item
+     *
+     * @param {FilterDefinitionItem} metadata a single item
+     * @returns {Promise.<FilterDefinitionItem>} Promise
+     */
+    static update(metadata: FilterDefinitionItem): Promise<FilterDefinitionItem>;
+    /**
+     * helper to allow us to select single metadata entries via REST
+     *
+     * @private
+     * @param {string} key customer key
+     * @returns {Promise.<string>} objectId or enpty string
+     */
+    private static _getObjectIdForSingleRetrieve;
+}
+declare namespace FilterDefinition {
+    let dataExtensionFieldCache: {
+        [x: string]: import("../../types/mcdev.d.js").DataExtensionFieldItem;
+    };
+    let definition: {
+        bodyIteratorField: string;
+        dependencies: string[];
+        dependencyGraph: {
+            dataExtension: string[];
+        };
+        filter: {};
+        hasExtended: boolean;
+        idField: string;
+        keyField: string;
+        nameField: string;
+        folderType: string;
+        folderIdField: string;
+        createdDateField: string;
+        createdNameField: string;
+        lastmodDateField: string;
+        lastmodNameField: string;
+        restPagination: boolean;
+        restPageSize: number;
+        type: string;
+        soapType: string;
+        typeDescription: string;
+        typeRetrieveByDefault: boolean;
+        typeName: string;
+        fields: {
+            id: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            key: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            createdDate: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            createdBy: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            createdByName: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            lastUpdated: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            lastUpdatedBy: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            lastUpdatedByName: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            name: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            categoryId: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            description: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            filterDefinitionXml: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            derivedFromType: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            derivedFromObjectId: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            derivedFromObjectTypeName: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            derivedFromObjectName: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            isSendable: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            r__source_dataExtension_key: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+            c__filterDefinition: {
+                skipValidation: boolean;
+            };
+            r__folder_Path: {
+                isCreateable: boolean;
+                isUpdateable: boolean;
+                retrieving: boolean;
+                template: boolean;
+            };
+        };
+    };
+}
+import MetadataType from './MetadataType.js';
+//# sourceMappingURL=FilterDefinition.d.ts.map

package/@types/lib/metadataTypes/FilterDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FilterDefinition.d.ts","sourceRoot":"","sources":["../../../lib/metadataTypes/FilterDefinition.js"],"names":[],"mappings":";uBAUa,OAAO,wBAAwB,EAAE,QAAQ;0BACzC,OAAO,wBAAwB,EAAE,WAAW;8BAC5C,OAAO,wBAAwB,EAAE,eAAe;+BAChD,OAAO,wBAAwB,EAAE,gBAAgB;mCACjD,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;8BACpD,OAAO,wBAAwB,EAAE,eAAe;iCAChD,OAAO,wBAAwB,EAAE,kBAAkB;gCACnD,OAAO,wBAAwB,EAAE,iBAAiB;0BAClD,OAAO,wBAAwB,EAAE,WAAW;mCAC5C,OAAO,wBAAwB,EAAE,oBAAoB;kCACrD,OAAO,wBAAwB,EAAE,mBAAmB;mCACpD,OAAO,wBAAwB,EAAE,oBAAoB;iCACrD,OAAO,wBAAwB,EAAE,kBAAkB;8BACnD,OAAO,wBAAwB,EAAE,eAAe;AAf7D;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH;IACI,iBAAkB;IAClB,uBAAkB;IAClB,uBAAsB;IACtB;;;;;;;;OAQG;IACH,6BANW,MAAM,MACN,MAAM,EAAE,OACR,MAAM,EAAE,QACR,MAAM,GACJ,OAAO,CAAE;QAAC,QAAQ,EAAE,mBAAmB,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAiDnE;IACD;;;;;OAKG;IACH,sCAHW,OAAO,GACL,OAAO,CAAE,MAAM,EAAE,CAAC,CA+B9B;IACD;;;;OAIG;IACH,+BAFa,OAAO,CAAE,MAAM,EAAE,CAAC,CA2B9B;IAED;;;;;OAKG;IACH,uCAHW,mBAAmB,SACnB,UAAU,GAAC,QAAQ,iBA0D7B;IACD;;;;OAIG;IACH,gDAFW,mBAAmB,iBAkB7B;IACD;;;;OAIG;IACH,uCAFW,mBAAmB,iBA6B7B;IAED;;;;OAIG;IACH,2BAFa,OAAO,CAAE;QAAC,QAAQ,EAAE,mBAAmB,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,CAAC,CAInE;IAED;;;;;OAKG;IACH,mCAHW,oBAAoB,GAClB,OAAO,CAAE,oBAAoB,CAAC,CA4F1C;IAED;;;;;;;;OAQG;IACH,gCANW,oBAAoB,QACpB,cAAc,GAAC,WAAW,eAC1B,MAAM,EAAE,WACR,kBAAkB,GAChB,IAAI,CAiChB;IACD;;;;;;OAMG;IACH,yDAJW,eAAe,cACf,MAAM,EAAE,GACN,IAAI,CAYhB;IACD;;;;;;OAMG;IACH,wDAJW,eAAe,cACf,MAAM,EAAE,GACN,IAAI,CAgBhB;IACD;;;;;;OAMG;IACH,mDAJW,oBAAoB,WACpB,MAAM,GACJ,IAAI,CAiChB;IAED;;;;;OAKG;IACH,gCAHW,oBAAoB,GAClB,OAAO,CAAE,oBAAoB,CAAC,CAuC1C;IAeD;;;;;OAKG;IACH,wBAHW,oBAAoB,GAClB,OAAO,CAAE,oBAAoB,CAAC,CAK1C;IACD;;;;;OAKG;IACH,wBAHW,oBAAoB,GAClB,OAAO,CAAE,oBAAoB,CAAC,CAQ1C;IAED;;;;;;OAMG;IACH,6CAUC;CAiBJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA9mBwB,mBAAmB"}