async function parseHierarchy(params) {

                const MAX_COLUMNS = 8
                const MAX_ROWS = 100

                const ELBOW = 'elbow'
                const FORK = 'fork'
                const LINE = 'line'
                const SPACE = 'space'

                let splittedParams = params.split('->')
                let project = splittedParams[0]
                let type = splittedParams[1]
                let levels = splittedParams[2]

                let projectSchema = SCHEMAS_BY_PROJECT.get(project)
                if(projectSchema === undefined) {
                    projectSchema = await ED.schemas.convertProjectsToSchemas(project).then(() => SCHEMAS_BY_PROJECT.get(project))
                }
                appSchemaDocument = projectSchema.map.appSchema.get(type)
                if(appSchemaDocument === undefined) {
                    return ''
                }
                if(isNaN(levels) === true) {
                    return ''
                }
                if(levels > MAX_COLUMNS) {
                    return ''
                }

                let contentMatrix = []

                for(let i = 0; i < MAX_ROWS; i++) {
                    contentMatrix.push(['', '', '', '', '', '', '', ''])
                }

                let currentColumn = 0
                let currentRow = -1

                return await scanHierarchy(appSchemaDocument, project, currentColumn)
                    .then(() => fillEmptySpaces())
                    .then(() => putTheLines())
                    .then(() => addImageContainers())
                    .then(() => addHTML())

                /**
                 * 
                 * @param {*} schemaDocument 
                 * @param {*} project 
                 * @param {*} currentColumn 
                 * @param {*} lastChild 
                 * @returns {Promise<void>}
                 */
                async function scanHierarchy(schemaDocument, project, currentColumn, lastChild) {

                    if(schemaDocument === undefined) {
                        return
                    }

                    currentRow++

                    let imageItem = {
                        div: 'hierarchy-image-div-' + hierarchyImagesArray.length,
                        project: project,
                        type: schemaDocument.type,
                        size: 50
                    }
                    let imageContainer = '<div id="' + imageItem.div + '" class="docs-hierarchy-image-container"/>'
                    hierarchyImagesArray.push(imageItem)

                    let matrixValue = '<table><tr><td class="docs-hierarchy-table-cell">' + imageContainer + '</td></tr><tr><td  class="docs-hierarchy-table-cell">' + await ED.utilities.addToolTips(schemaDocument.type, thisObject.currentDocumentBeingRendered.type) + '</td></tr></table>'
                    let matrixRow = contentMatrix[currentRow]
                    matrixRow[currentColumn] = matrixValue

                    if(lastChild === true) {
                        matrixRow[currentColumn - 1] = ELBOW
                    }
                    if(lastChild === false) {
                        matrixRow[currentColumn - 1] = FORK
                    }

                    if(schemaDocument.childrenNodesProperties === undefined) {
                        return
                    }

                    for(let i = 0; i < schemaDocument.childrenNodesProperties.length; i++) {
                        let property = schemaDocument.childrenNodesProperties[i]
                        let childProject = project
                        if(property.project !== undefined) {
                            childProject = property.project
                        }
                        let childType = property.childType
                        let childSchemaDocument = SCHEMAS_BY_PROJECT.get(project).map.appSchema.get(childType)

                        if(i === schemaDocument.childrenNodesProperties.length - 1) {
                            lastChild = true
                        } else {
                            lastChild = false
                        }

                        if(currentColumn + 1 < levels) {
                            await scanHierarchy(childSchemaDocument, childProject, currentColumn + 1, lastChild)
                        }
                    }
                }

                function fillEmptySpaces() {
                    /*
                    Fill the empty spaces
                    */
                    for(let i = 0; i < contentMatrix.length; i++) {
                        let matrixRow = contentMatrix[i]
                        for(let j = 0; j < matrixRow.length; j++) {
                            if(matrixRow[j] === '') {
                                matrixRow[j] = SPACE
                            }
                        }
                    }
                }

                function putTheLines() {
                    /*
                    Now we will scan the Matrix to put the lines of the hierarchy.
                    */
                    for(let i = 0; i < contentMatrix.length; i++) {
                        let matrixRow = contentMatrix[i]
                        let previousRow = contentMatrix[i - 1]
                        for(let j = 0; j < matrixRow.length; j++) {
                            if(previousRow && matrixRow[j] === SPACE) {
                                if(previousRow[j] === FORK || previousRow[j] === LINE) {
                                    matrixRow[j] = LINE
                                }
                            }
                        }
                    }
                }

                function addImageContainers() {
                    /*
                    Add Image Containers
                    */
                    for(let i = 0; i < contentMatrix.length; i++) {
                        let matrixRow = contentMatrix[i]
                        for(let j = 0; j < matrixRow.length; j++) {

                            let imageItem = {
                                div: 'hierarchy-image-div-' + hierarchyImagesArray.length,
                                project: 'Foundations'
                            }

                            switch(matrixRow[j]) {
                                case LINE: {
                                    imageItem.name = 'tree-connector-line'
                                    matrixRow[j] = generateMatrixRow(imageItem.div)
                                    hierarchyImagesArray.push(imageItem)
                                    break
                                }
                                case SPACE: {
                                    imageItem.name = 'tree-spacer'
                                    matrixRow[j] = generateMatrixRow(imageItem.div)
                                    hierarchyImagesArray.push(imageItem)
                                    break
                                }
                                case FORK: {
                                    imageItem.name = 'tree-connector-fork'
                                    matrixRow[j] = generateMatrixRow(imageItem.div)
                                    hierarchyImagesArray.push(imageItem)
                                    break
                                }
                                case ELBOW: {
                                    imageItem.name = 'tree-connector-elbow'
                                    matrixRow[j] = generateMatrixRow(imageItem.div)
                                    hierarchyImagesArray.push(imageItem)
                                    break
                                }
                            }

                        }
                    }

                    function generateMatrixRow(imageItemDiv) {
                        return '<div id="' + imageItemDiv + '" class="docs-hierarchy-image-container"/>'
                    }
                }

                /**
                 * 
                 * @returns {string}
                 */
                function addHTML() {
                    /*
                     * Add HTML
                     */
                    let html = ''
                    let oddRow = false
                    for(let i = 0; i < currentRow + 1; i++) {
                        let matrixRow = contentMatrix[i]

                        let rowClass
                        if(oddRow === false) {
                            oddRow = true
                            rowClass = ''
                        } else {
                            oddRow = false
                            rowClass = 'class="docs-hierarchy-table-row"'
                        }

                        html = html + '<tr ' + rowClass + '>'
                        for(let j = 0; j < matrixRow.length; j++) {
                            html = html + '<td class="docs-hierarchy-table-cell"><center>'
                            html = html + matrixRow[j]
                            html = html + '</center></td>'
                        }
                        html = html + '</tr>'
                    }
                    return html
                }
            }
@param {string} params 
@returns {Promise<string>}