function installInChartingSpace(chartingSpace) {

                for (let j = 0; j < chartingSpace.projectDashboards.length; j++) {
                    let projectDashboard = chartingSpace.projectDashboards[j]

                    for (let k = 0; k < projectDashboard.dashboards.length; k++) {
                        let dashboard = projectDashboard.dashboards[k]

                        for (let l = 0; l < dashboard.timeMachines.length; l++) {
                            let timeMachine = dashboard.timeMachines[l]

                            if (timeMachine.timelineCharts.length > 0) {
                                let existingTimelineChartUpdated = false
                                /**
                                 * We first search the existing timeline charts for a Layer Manager children that references our product data mine parent, to reuse it
                                 * If none found we will create a new timeline chart with all branches
                                 */
                                for (let m = 0; m < timeMachine.timelineCharts.length; m++) {
                                    let currentTimelineChart = timeMachine.timelineCharts[m]

                                    let referencedLayerManager = UI.projects.visualScripting.utilities.nodeChildren.findChildReferencingThisNode(currentTimelineChart, dataMineProduct)
                                    if (referencedLayerManager !== undefined) {
                                        // We have found a timeline chart that references our product data mine, let's check if our product is installed, otherwise we install it
                                        let botLayer = createBotLayerIfNotPresent(referencedLayerManager)
                                        createLayerIfNotPresent(botLayer)
                                        existingTimelineChartUpdated = true
                                    }

                                }
                                // None of the existing timeline charts are referencing our data mine, so let's create it
                                if (existingTimelineChartUpdated === false) {
                                    createTimelineChartWithAllBranches(timeMachine)
                                }
                            } else {
                                //No timeline chart exists at all, so let's create one for our data mine
                                createTimelineChartWithAllBranches(timeMachine)
                            }

                            function createTimelineChartWithAllBranches(timeMachine) {
                                let newTimelineChart = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(timeMachine, 'Timeline Chart')
                                newTimelineChart.name = productDataMineParent.name

                                let layerManager = newTimelineChart.layerManager
                                UI.projects.visualScripting.nodeActionFunctions.attachDetach.referenceAttachNode(layerManager, dataMineProduct)

                                let botLayer = createBotLayerIfNotPresent(layerManager)
                                createLayerIfNotPresent(botLayer)

                            }

                            function createBotLayerIfNotPresent(layerManager) {
                                let botLayer = UI.projects.visualScripting.utilities.meshes.findNodeInNodeMesh(layerManager, undefined, productParentBot.name, false, true, false, false)

                                if (botLayer === undefined) {
                                    let newBotLayer = UI.projects.visualScripting.nodeActionFunctions.uiObjectsFromNodes.addUIObject(layerManager, 'Bot Layers')
                                    newBotLayer.name = productParentBot.name
                                    return newBotLayer
                                }
                                return botLayer
                            }

                            function createLayerIfNotPresent(botLayer) {
                                UI.projects.visualScripting.utilities.nodeChildren.findOrCreateChildWithReference(botLayer, 'Layer', dataProduct)
                            }
                        }
                    }
                }
            }
This function will install the product into existing Charting Space
It is mandatory to have at least a dashboard which contains at least one time machine