@umbraco/playwright-testhelpers 2.0.0-beta.9 → 15.0.0-beta.1

package/dist/lib/helpers/DataTypeApiHelper.js

@@ -1,81 +1,47 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DataTypeApiHelper = void 0;
+const json_models_builders_1 = require("@umbraco/json-models-builders");
 class DataTypeApiHelper {
     api;
     constructor(api) {
         this.api = api;
     }
-    async ensureNameNotExistsAtRoot(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                if (sb.isFolder == false) {
-                    return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + sb.id);
-                }
-                else {
-                    if (sb.hasChildren == true) {
-                        return await this.recurseFolderChildren(sb.id);
-                    }
-                    else {
-                        return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + sb.id);
-                    }
-                }
-            }
-        }
-        return null;
-    }
     async get(id) {
         const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id);
-        const json = await response.json();
-        if (json !== null) {
-            return json;
-        }
-        return null;
-    }
-    async getByNameAtRoot(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                if (sb.id !== null) {
-                    const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + sb.id);
-                    return response.json();
-                }
-            }
-        }
-        return null;
+        return await response.json();
     }
-    async create(name, editorAlias, values, parentId, editorUiAlias) {
+    async create(name, editorAlias, editorUiAlias, values, parentId, id) {
         const dataType = {
             "name": name,
             "editorAlias": editorAlias,
             "editorUiAlias": editorUiAlias,
             "values": values,
-            "parentId": parentId
+            "id": id,
+            "parent": parentId ? { "id": parentId } : null
         };
         const response = await this.api.post(this.api.baseUrl + '/umbraco/management/api/v1/data-type', dataType);
         // Returns the id of the created dataType
-        return response.headers().location.split("/").pop();
+        return response.headers().location.split("v1/data-type/").pop();
     }
     async update(id, dataType) {
-        return await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id, dataType);
+        const updateDataType = {
+            "name": dataType.name,
+            "editorAlias": dataType.editorAlias,
+            "editorUiAlias": dataType.editorUiAlias,
+            "values": dataType.values,
+        };
+        return await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id, updateDataType);
     }
     async delete(id) {
         return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id);
     }
-    async deleteByNameAtRoot(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                if (sb.id !== null) {
-                    return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + sb.id);
-                }
-            }
-        }
-        return null;
+    async getAllAtRoot() {
+        return await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
+    }
+    async doesExist(id) {
+        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id);
+        return response.status() === 200;
     }
     async getItems(ids) {
         let idArray = 'id=' + ids[0];
@@ -84,124 +50,857 @@ class DataTypeApiHelper {
             idArray += '&id=' + ids[i];
         }
         const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/item?' + idArray);
-        const json = await response.json();
-        if (json !== null) {
-            return json;
-        }
-        return null;
+        return await response.json();
     }
-    async getAllAtRoot() {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
-        const json = await response.json();
-        if (json !== null) {
-            return json;
+    async getByName(name) {
+        const rootDataTypes = await this.getAllAtRoot();
+        const jsonDataTypes = await rootDataTypes.json();
+        for (const dataType of jsonDataTypes.items) {
+            if (dataType.name === name) {
+                return this.get(dataType.id);
+            }
+            else if (dataType.isContainer || dataType.hasChildren) {
+                const result = await this.recurseChildren(name, dataType.id, false);
+                if (result) {
+                    return result;
+                }
+            }
         }
-        return null;
-    }
-    async exists(id) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + id);
-        return response.status() === 200;
+        return false;
     }
-    async nameExistsAtRoot(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=false');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                return true;
+    async ensureNameNotExists(name) {
+        const rootDataTypes = await this.getAllAtRoot();
+        const jsonDataTypes = await rootDataTypes.json();
+        for (const dataType of jsonDataTypes.items) {
+            if (dataType.name === name) {
+                if (dataType.isFolder) {
+                    return await this.recurseDeleteChildren(dataType);
+                }
+                return await this.delete(dataType.id);
+            }
+            else if (dataType.hasChildren) {
+                await this.recurseChildren(name, dataType.id, true);
             }
         }
-        return false;
+        return null;
+    }
+    async doesNameExist(name) {
+        return await this.getByName(name);
     }
     async moveToFolder(dataTypeId, folderId) {
         const folderIdBody = {
-            "targetId": folderId
+            "target": { id: folderId }
         };
-        return await this.api.post(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + dataTypeId + '/move', folderIdBody);
+        return await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + dataTypeId + '/move', folderIdBody);
     }
     async copyToFolder(dataTypeId, folderId) {
         const folderIdBody = {
-            "targetId": folderId
+            "target": { id: folderId }
         };
         const response = await this.api.post(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + dataTypeId + '/copy', folderIdBody);
         // Returns the id of the copied dataType
-        return response.headers().location.split("/").pop();
+        return response.headers().location.split("v1/data-type/").pop();
     }
     // FOLDER
     async getFolder(id) {
         const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id);
         return await response.json();
     }
-    async folderExists(id) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id);
-        return response.status() === 200;
-    }
-    async getFolderByName(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=true');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                if (sb.id !== null) {
-                    const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + sb.id);
-                    return response.json();
-                }
-            }
-        }
-        return null;
-    }
-    async createFolder(name, parentId) {
+    async createFolder(name, parentId, id) {
         const folderData = {
             "name": name,
-            "parentId": parentId
+            "id": id,
+            "parent": parentId ? { "id": parentId } : null
         };
         const response = await this.api.post(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder', folderData);
         // Returns the id of the created dataTypeFolder
-        return response.headers().location.split("/").pop();
+        return response.headers().location.split("v1/data-type/folder/").pop();
     }
-    async updateFolder(id, dataTypeFolder) {
-        return await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id, dataTypeFolder);
+    async renameFolder(id, name) {
+        const folderData = {
+            "name": name,
+        };
+        return await this.api.put(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id, folderData);
     }
     async deleteFolder(id) {
         return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id);
     }
-    async deleteFolderByName(name) {
-        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/root?skip=0&take=10000&foldersOnly=true');
-        const json = await response.json();
-        for (const sb of json.items) {
-            if (sb.name === name) {
-                if (sb.id !== null) {
-                    return await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + sb.id);
-                }
-            }
-        }
-        return null;
+    async doesFolderExist(id) {
+        const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id);
+        return response.status() === 200;
     }
     async getChildren(id) {
         const response = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/children?parentId=' + id + '&skip=0&take=100&foldersOnly=false');
-        const json = await response.json();
-        if (json !== null) {
-            return json;
+        const items = await response.json();
+        return items.items;
+    }
+    async recurseDeleteChildren(dataFolder) {
+        if (!dataFolder.hasChildren) {
+            return await this.deleteFolder(dataFolder.id);
         }
-        return null;
+        const items = await this.getChildren(dataFolder.id);
+        for (const child of items) {
+            if (child.hasChildren) {
+                await this.recurseDeleteChildren(child);
+            }
+            else if (child.isFolder) {
+                await this.deleteFolder(child.id);
+            }
+            else {
+                await this.delete(child.id);
+            }
+        }
+        return await this.deleteFolder(dataFolder.id);
     }
-    async recurseFolderChildren(id) {
-        const parentDataType = await this.api.get(this.api.baseUrl + '/umbraco/management/api/v1/tree/data-type/children?parentId=' + id + '&skip=0&take=10000');
-        const itemsJson = await parentDataType.json();
-        for (const child of itemsJson.items) {
-            if (child.path !== null) {
-                if (child.isFolder == true) {
-                    if (child.hasChildren == true) {
-                        await this.recurseFolderChildren(child.path);
-                    }
-                    else {
-                        await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + child.id);
+    async recurseChildren(name, id, toDelete) {
+        const items = await this.getChildren(id);
+        for (const child of items) {
+            if (child.name === name) {
+                if (!toDelete) {
+                    if (child.isFolder) {
+                        return await this.getFolder(child.id);
                     }
+                    return await this.get(child.id);
                 }
-                else {
-                    await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/' + child.id);
+                if (child.isFolder) {
+                    return await this.recurseDeleteChildren(child);
                 }
+                return await this.delete(child.id);
             }
+            else if (child.hasChildren) {
+                return await this.recurseChildren(name, child.id, toDelete);
+            }
+        }
+        return false;
+    }
+    async save(dataType) {
+        const response = await this.api.post(this.api.baseUrl + '/umbraco/management/api/v1/data-type', dataType);
+        return response.headers().location.split("v1/data-type/").pop();
+    }
+    async createDateTypeDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DatePickerDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createCheckboxListDataType(name, options) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.CheckboxListDataTypeBuilder()
+            .withName(name)
+            .withItems(options)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithStartNode(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withStartNodeId(startNodeId)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithShowOpenButton(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withShowOpenButton(true)
+            .build();
+        return await this.save(dataType);
+    }
+    async createContentPickerDataTypeWithIgnoreUserStartNodes(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ContentPickerDataTypeBuilder()
+            .withName(name)
+            .withStartNodeId(startNodeId)
+            .withIgnoreUserStartNodes(true)
+            .build();
+        return await this.save(dataType);
+    }
+    async createDatePickerDataType(name, dateFormat) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DatePickerDataTypeBuilder()
+            .withName(name)
+            .withFormat(dateFormat)
+            .build();
+        return await this.save(dataType);
+    }
+    async createDropdownDataType(name, isMultiple, options) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DropdownDataTypeBuilder()
+            .withName(name)
+            .withMultiple(isMultiple)
+            .withItems(options)
+            .build();
+        return await this.save(dataType);
+    }
+    // BlockListEditor
+    async createEmptyBlockListDataType(name) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithABlock(name, contentElementTypeId) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithContentAndSettingsElementType(name, contentElementTypeId, settingsElementTypeId) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withSettingsElementTypeKey(settingsElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithMinAndMaxAmount(name, minAmount = 0, maxAmount = 0) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withMinValue(minAmount)
+            .withMaxValue(maxAmount)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithSingleBlockMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withSingleBlockMode(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithLiveEditingMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withLiveEditing(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithInlineEditingMode(name, enabled) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withInlineEditingAsDefault(enabled)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListDataTypeWithPropertyEditorWidth(name, width) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .withMaxPropertyWidth(width)
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithEditorAppearance(name, elementTypeId, label = '', overlaySize = 'small') {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withLabel(label)
+            .withEditorSize(overlaySize)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithCatalogueAppearance(name, elementTypeId, backgroundColor = '', iconColor = '', customStylesheet = '') {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withBackgroundColor(backgroundColor)
+            .withIconColor(iconColor)
+            .withStylesheet(customStylesheet)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async createBlockListWithBlockWithHideContentEditor(name, elementTypeId, hideContentEditor) {
+        await this.ensureNameNotExists(name);
+        const blockList = new json_models_builders_1.BlockListDataTypeBuilder()
+            .withName(name)
+            .addBlock()
+            .withContentElementTypeKey(elementTypeId)
+            .withHideContentEditor(hideContentEditor)
+            .done()
+            .build();
+        return await this.save(blockList);
+    }
+    async isSingleBlockModeEnabledForBlockList(blockListName, enabled) {
+        const blockList = await this.getByName(blockListName);
+        const singleBlockModeValue = blockList.values.find(value => value.alias === 'useSingleBlockMode');
+        return singleBlockModeValue?.value === enabled;
+    }
+    async isInlineEditingModeEnabledForBlockList(blockListName, enabled) {
+        const blockList = await this.getByName(blockListName);
+        const inlineEditingModeValue = blockList.values.find(value => value.alias === 'useInlineEditingAsDefault');
+        return inlineEditingModeValue?.value === enabled;
+    }
+    // Block Grid
+    async createEmptyBlockGrid(blockGridName) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithABlock(blockGridName, contentElementTypeId) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithABlockInAGroup(blockGridName, contentElementTypeId, groupName) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlockGroup()
+            .withName(groupName)
+            .done()
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withGroupName(groupName)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithMinAndMaxAmount(blockGridName, minAmount = 0, maxAmount = 0) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withMinValue(minAmount)
+            .withMaxValue(maxAmount)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLiveEditingMode(blockGridName, enabled) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withLiveEditing(enabled)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithPropertyEditorWidth(blockGridName, width) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withMaxPropertyWidth(width)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithCreateButtonLabel(blockGridName, label = '') {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withCreateLabel(label)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithGridColumns(blockGridName, columns = 12) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withGridColumns(columns)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLayoutStylesheet(blockGridName, stylesheet = ['']) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .withLayoutStylesheet(stylesheet)
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithAnAreaInABlock(blockGridName, contentElementTypeId, areaAlias = 'area', createButtonLabel = '', columnSpan = 6, rowSpan = 1, minAllowed = 0, maxAllowed = 2) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .addArea()
+            .withAlias(areaAlias)
+            .withCreateLabel(createButtonLabel)
+            .withColumnSpan(columnSpan)
+            .withRowSpan(rowSpan)
+            .withMinAllowed(minAllowed)
+            .withMaxAllowed(maxAllowed)
+            .done()
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithAdvancedSettingsInBlock(blockGridName, contentElementTypeId, customViewPath = '', customStylesheetPath = '', overlaySize = 'small', inlineEditing = false, hideContentEditor = false) {
+        await this.ensureNameNotExists(blockGridName);
+        const encodedViewPath = await this.api.stylesheet.encodeStylesheetPath(customViewPath);
+        const encodedStylesheetPath = await this.api.stylesheet.encodeStylesheetPath(customStylesheetPath);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withView(encodedViewPath)
+            .withStylesheet(encodedStylesheetPath)
+            .withEditorSize(overlaySize)
+            .withInlineEditing(inlineEditing)
+            .withHideContentEditor(hideContentEditor)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithCatalogueAppearanceInBlock(blockGridName, contentElementTypeId, backgroundColor = '', iconColor = '', thumbnail = '') {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withBackgroundColor(backgroundColor)
+            .withIconColor(iconColor)
+            .withThumbnail(thumbnail)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithContentAndSettingsElementType(blockGridName, contentElementTypeId, settingsElementTypeId) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withSettingsElementTypeKey(settingsElementTypeId)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithLabel(blockGridName, contentElementTypeId, label) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withLabel(label)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithPermissions(blockGridName, contentElementTypeId, toAllowInRoot = false, toAllowInAreas = false) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .withAllowAtRoot(toAllowInRoot)
+            .withAllowInAreas(toAllowInAreas)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async createBlockGridWithSizeOptions(blockGridName, contentElementTypeId, columnSpans = 0, minRowSpan = 0, maxRowSpan = 12) {
+        await this.ensureNameNotExists(blockGridName);
+        const blockGrid = new json_models_builders_1.BlockGridDataTypeBuilder()
+            .withName(blockGridName)
+            .addBlock()
+            .withContentElementTypeKey(contentElementTypeId)
+            .addColumnSpanOptions(columnSpans)
+            .withMinRowSpan(minRowSpan)
+            .withMaxRowSpan(maxRowSpan)
+            .done()
+            .build();
+        return await this.save(blockGrid);
+    }
+    async doesBlockEditorContainBlocksWithContentTypeIds(blockEditorName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockEditorName);
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const contentElementTypeKeys = blocksValue.value.map(block => block.contentElementTypeKey);
+        return elementTypeIds.every(id => contentElementTypeKeys.includes(id));
+    }
+    async doesBlockEditorContainBlocksWithSettingsTypeIds(blockEditorName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockEditorName);
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const settingsElementTypeKeys = blocksValue.value.map(block => block.settingsElementTypeKey);
+        return elementTypeIds.every(id => settingsElementTypeKeys.includes(id));
+    }
+    async isLiveEditingModeEnabledForBlockEditor(blockEditorName, enabled) {
+        const blockEditor = await this.getByName(blockEditorName);
+        const liveEditingModeValue = blockEditor.values.find(value => value.alias === 'useLiveEditing');
+        return liveEditingModeValue?.value === enabled;
+    }
+    async doesMaxPropertyContainWidthForBlockEditor(blockEditorName, width) {
+        const blockEditor = await this.getByName(blockEditorName);
+        const maxPropertyWidthValue = blockEditor.values.find(value => value.alias === 'maxPropertyWidth');
+        return maxPropertyWidthValue?.value === width;
+    }
+    async doesBlockEditorBlockContainLabel(blockName, elementTypeKey, label) {
+        const block = await this.getBlockWithContentElementTypeId(blockName, elementTypeKey);
+        return block.label === label;
+    }
+    async doesBlockGridGroupContainCorrectBlocks(blockGridName, groupName, elementTypeIds) {
+        if (!elementTypeIds || elementTypeIds.length === 0) {
+            return false;
+        }
+        const blockEditor = await this.getByName(blockGridName);
+        // We need to get the GroupKey, so we can use it to find the blocks that use the Key.
+        const blockGroupsValue = blockEditor.values.find(value => value.alias === 'blockGroups');
+        if (!blockGroupsValue || blockGroupsValue.value.length === 0) {
+            return false;
+        }
+        const blockGroupKey = blockGroupsValue.value.find(blockGroup => blockGroup.name === groupName).key;
+        const blocksValue = blockEditor.values.find(value => value.alias === 'blocks');
+        if (!blocksValue || blocksValue.value.length === 0) {
+            return false;
+        }
+        const blocksWithGroupKey = blocksValue.value.filter(block => block.groupKey === blockGroupKey);
+        return elementTypeIds.every(id => blocksWithGroupKey.some(block => block.contentElementTypeKey === id));
+    }
+    async doesBlockGridContainCreateButtonLabel(blockGridName, label) {
+        const blockEditor = await this.getByName(blockGridName);
+        const createLabelValue = blockEditor.values.find(value => value.alias === 'createLabel');
+        return createLabelValue?.value === label;
+    }
+    async doesBlockGridContainGridColumns(blockGridName, columns) {
+        const blockEditor = await this.getByName(blockGridName);
+        const gridColumnsValue = blockEditor.values.find(value => value.alias === 'gridColumns');
+        return gridColumnsValue?.value === columns;
+    }
+    async doesBlockEditorBlockHaveAllowInRootEnabled(blockGridName, elementTypeKey) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.allowAtRoot;
+    }
+    async doesBlockEditorBlockHaveAllowInAreasEnabled(blockGridName, elementTypeKey) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.allowInAreas;
+    }
+    async doesBlockEditorBlockContainColumnSpanOptions(blockGridName, elementTypeKey, expectedColumnSpans) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        // If the block does not have any columnSpanOptions, and we are not expecting any, return true
+        if (block.columnSpanOptions.length === 0 && expectedColumnSpans.length === 0) {
+            return true;
+        }
+        const columnSpans = block.columnSpanOptions.map(option => option.columnSpan);
+        return expectedColumnSpans.every(span => columnSpans.includes(span)) && columnSpans.every(span => expectedColumnSpans.includes(span));
+    }
+    async doesBlockEditorBlockContainRowSpanOptions(blockGridName, elementTypeKey, minRowSpan, maxRowSpan) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.rowMinSpan === minRowSpan && block.rowMaxSpan === maxRowSpan;
+    }
+    async doesBlockEditorBlockContainAreaGridColumns(blockGridName, elementTypeKey, areaGridColumns) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areaGridColumns === areaGridColumns;
+    }
+    async doesBlockEditorBlockContainAreaWithAlias(blockGridName, elementTypeKey, areaAlias = 'area') {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaCount(blockGridName, elementTypeKey, areaCount) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.length === areaCount;
+    }
+    async doesBlockEditorBlockContainAreaWithCreateButtonLabel(blockGridName, elementTypeKey, areaAlias = 'area', createButtonLabel) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.createLabel === createButtonLabel && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaWithMinAllowed(blockGridName, elementTypeKey, areaAlias = 'area', minAllowed) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.minAllowed === minAllowed && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainAreaWithMaxAllowed(blockGridName, elementTypeKey, areaAlias = 'area', maxAllowed) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.areas.find(area => area.maxAllowed === maxAllowed && area.alias === areaAlias);
+    }
+    async doesBlockEditorBlockContainStylesheet(blockGridName, elementTypeKey, stylesheetPath) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        const encodedSecondStylesheetPath = await this.api.stylesheet.encodeStylesheetPath(stylesheetPath);
+        return block.stylesheet[0] === encodedSecondStylesheetPath;
+    }
+    async doesBlockEditorBlockContainOverlaySize(blockGridName, elementTypeKey, overlaySize) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.editorSize === overlaySize;
+    }
+    async doesBlockEditorBlockContainInlineEditing(blockGridName, elementTypeKey, inlineEditing) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.inlineEditing === inlineEditing;
+    }
+    async doesBlockEditorBlockContainHideContentEditor(blockGridName, elementTypeKey, hideContentEditor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.hideContentEditor === hideContentEditor;
+    }
+    async doesBlockEditorBlockContainBackgroundColor(blockGridName, elementTypeKey, backgroundColor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.backgroundColor === backgroundColor;
+    }
+    async doesBlockEditorBlockContainIconColor(blockGridName, elementTypeKey, iconColor) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.iconColor === iconColor;
+    }
+    async doesBlockEditorBlockContainThumbnail(blockGridName, elementTypeKey, thumbnail) {
+        const block = await this.getBlockWithContentElementTypeId(blockGridName, elementTypeKey);
+        return block.thumbnail === thumbnail;
+    }
+    async getBlockWithContentElementTypeId(blockGridName, contentElementTypeKey) {
+        const blockEditor = await this.getByName(blockGridName);
+        const blocks = blockEditor.values.find(value => value.alias === 'blocks');
+        return blocks.value.find(block => block.contentElementTypeKey === contentElementTypeKey);
+    }
+    async createImageCropperDataTypeWithOneCrop(name, cropLabel, cropWidth, cropHeight) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ImageCropperDataTypeBuilder()
+            .withName(name)
+            .addCrop()
+            .withLabel(cropLabel)
+            .withAlias(json_models_builders_1.AliasHelper.toAlias(cropLabel))
+            .withHeight(cropHeight)
+            .withWidth(cropWidth)
+            .done()
+            .build();
+        return await this.save(dataType);
+    }
+    async createMediaPickerDataTypeWithStartNodeId(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.MediaPickerDataTypeBuilder()
+            .withName(name)
+            .withStartNodeId(startNodeId)
+            .withIgnoreUserStartNodes(false)
+            .build();
+        return await this.save(dataType);
+    }
+    async createRadioboxDataType(name, options) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.RadioboxDataTypeBuilder()
+            .withName(name)
+            .withItems(options)
+            .build();
+        return await this.save(dataType);
+    }
+    async createImageMediaPickerDataType(name, minValue = 0, maxValue = 1, enableLocalFocalPoint = false, ignoreUserStartNodes = false) {
+        await this.ensureNameNotExists(name);
+        const mediaType = await this.api.mediaType.getByName('Image');
+        const dataType = new json_models_builders_1.MediaPickerDataTypeBuilder()
+            .withName(name)
+            .withFilter(mediaType.id)
+            .withMultiple(false)
+            .withMinValue(minValue)
+            .withMaxValue(maxValue)
+            .withEnableLocalFocalPoint(enableLocalFocalPoint)
+            .withIgnoreUserStartNodes(ignoreUserStartNodes)
+            .build();
+        return await this.save(dataType);
+    }
+    async createImageMediaPickerDataTypeWithStartNodeId(name, startNodeId) {
+        await this.ensureNameNotExists(name);
+        const mediaType = await this.api.mediaType.getByName('Image');
+        const dataType = new json_models_builders_1.MediaPickerDataTypeBuilder()
+            .withName(name)
+            .withFilter(mediaType.id)
+            .withStartNodeId(startNodeId)
+            .build();
+        return await this.save(dataType);
+    }
+    async createImageMediaPickerDataTypeWithCrop(name, label, width, height) {
+        await this.ensureNameNotExists(name);
+        const mediaType = await this.api.mediaType.getByName('Image');
+        const dataType = new json_models_builders_1.MediaPickerDataTypeBuilder()
+            .withName(name)
+            .withFilter(mediaType.id)
+            .addCrop()
+            .withLabel(label)
+            .withAlias(json_models_builders_1.AliasHelper.toAlias(label))
+            .withHeight(height)
+            .withWidth(width)
+            .done()
+            .build();
+        return await this.save(dataType);
+    }
+    async createTextareaDataType(name, maxChars = 0, rows = 0, minHeight = 0, maxHeight = 0) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.TextAreaDataTypeBuilder()
+            .withName(name)
+            .withMaxChars(maxChars)
+            .withRows(rows)
+            .withMinHeight(minHeight)
+            .withMaxHeight(maxHeight)
+            .build();
+        return await this.save(dataType);
+    }
+    async createTextstringDataType(name, maxChars = 0) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.TextStringDataTypeBuilder()
+            .withName(name)
+            .withMaxChars(maxChars)
+            .build();
+        return await this.save(dataType);
+    }
+    async createTrueFalseDataTypeWithInitialState(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.TrueFalseDataTypeBuilder()
+            .withName(name)
+            .withIsDefault(true)
+            .build();
+        return await this.save(dataType);
+    }
+    async createTrueFalseDataTypeWithLabelOn(name, labelOn) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.TrueFalseDataTypeBuilder()
+            .withName(name)
+            .withShowLabels(true)
+            .withLabelOn(labelOn)
+            .build();
+        return await this.save(dataType);
+    }
+    async createTrueFalseDataTypeWithLabelOff(name, labelOff) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.TrueFalseDataTypeBuilder()
+            .withName(name)
+            .withShowLabels(true)
+            .withLabelOff(labelOff)
+            .build();
+        return await this.save(dataType);
+    }
+    async createEmailAddressDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.EmailAddressDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createCodeEditorDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.CodeEditorDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createMarkdownEditorDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.MarkdownEditorDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createDecimalDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.DecimalDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createMultipleTextStringDataType(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.MultipleTextStringDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    async createSliderDataTyper(name) {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.SliderDataTypeBuilder()
+            .withName(name)
+            .build();
+        return await this.save(dataType);
+    }
+    // List View - Content data type
+    async createListViewContentDataType(name = 'List View - Content Test') {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ListViewDataTypeBuilder()
+            .withName(name)
+            .withPageSize(100)
+            .addLayout()
+            .withName('List')
+            .withIcon('icon-list')
+            .withCollectionView('Umb.CollectionView.Document.Table')
+            .done()
+            .addLayout()
+            .withName('Grid')
+            .withIcon('icon-grid')
+            .withCollectionView('Umb.CollectionView.Document.Grid')
+            .done()
+            .addColumnDisplayedProperty()
+            .withAlias('updateDate')
+            .withHeader('Last edited')
+            .done()
+            .addColumnDisplayedProperty()
+            .withAlias('creator')
+            .withHeader('Updated by')
+            .done()
+            .build();
+        return await this.save(dataType);
+    }
+    async createListViewContentDataTypeWithAllPermissions(name = 'List View - Content Test') {
+        await this.ensureNameNotExists(name);
+        const dataType = new json_models_builders_1.ListViewDataTypeBuilder()
+            .withName(name)
+            .withPageSize(100)
+            .addLayout()
+            .withName('List')
+            .withIcon('icon-list')
+            .withCollectionView('Umb.CollectionView.Document.Table')
+            .done()
+            .addLayout()
+            .withName('Grid')
+            .withIcon('icon-grid')
+            .withCollectionView('Umb.CollectionView.Document.Grid')
+            .done()
+            .addColumnDisplayedProperty()
+            .withAlias('updateDate')
+            .withHeader('Last edited')
+            .done()
+            .addColumnDisplayedProperty()
+            .withAlias('creator')
+            .withHeader('Updated by')
+            .done()
+            .addBulkActionPermissions()
+            .withAllowBulkCopy(true)
+            .withAllowBulkDelete(true)
+            .withAllowBulkMove(true)
+            .withAllowBulkPublish(true)
+            .withAllowBulkUnPublish(true)
+            .done()
+            .build();
+        return await this.save(dataType);
+    }
+    // List View - Media data type
+    async updateListViewMediaDataType(alias, newValue) {
+        const listViewMediaData = await this.getByName('List View - Media');
+        const valueData = listViewMediaData.values.find(value => value.alias === alias);
+        if (valueData) {
+            valueData.value = newValue;
+        }
+        else {
+            listViewMediaData.values.push({
+                "alias": alias,
+                "value": newValue
+            });
         }
-        await this.api.delete(this.api.baseUrl + '/umbraco/management/api/v1/data-type/folder/' + id);
+        return await this.update(listViewMediaData.id, listViewMediaData);
     }
 }
 exports.DataTypeApiHelper = DataTypeApiHelper;