diff --git a/.github/workflows/e2e-dev.yml b/.github/workflows/e2e-dev.yml
new file mode 100644
index 000000000..832a328bf
--- /dev/null
+++ b/.github/workflows/e2e-dev.yml
@@ -0,0 +1,70 @@
+name: 'e2e-dev'
+
+on:
+    workflow_call:
+        secrets:
+            username:
+                required: true
+            password:
+                required: true
+            recordkey:
+                required: true
+
+concurrency:
+    group: e2e-dev-${{ github.workflow}}-${{ github.ref }}
+    cancel-in-progress: true
+
+defaults:
+    run:
+        shell: bash
+
+jobs:
+    compute-dev-version:
+        runs-on: ubuntu-latest
+        outputs:
+            version: ${{ steps.instance-version.outputs.version }}
+        steps:
+            - name: Output dev version
+              id: instance-version
+              uses: dhis2/action-instance-version@v1
+              with:
+                  instance-url: https://test.e2e.dhis2.org/analytics-2.41d
+                  username: ${{ secrets.username }}
+                  password: ${{ secrets.password }}
+
+    e2e-dev:
+        needs: compute-dev-version
+        runs-on: ubuntu-latest
+
+        strategy:
+            fail-fast: false
+            matrix:
+                containers: [1, 2, 3, 4]
+
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v3
+
+            - uses: actions/setup-node@v3
+              with:
+                  node-version: 18.x
+
+            - name: Run e2e tests
+              uses: cypress-io/github-action@v5
+              with:
+                  start: yarn d2-app-scripts start
+                  wait-on: 'http://localhost:3000'
+                  wait-on-timeout: 300
+                  record: true
+                  parallel: true
+                  browser: chrome
+                  group: e2e-chrome-parallel-dev
+              env:
+                  BROWSER: none
+                  CYPRESS_RECORD_KEY: ${{ secrets.recordkey }}
+                  CYPRESS_dhis2BaseUrl: https://test.e2e.dhis2.org/analytics-2.41d
+                  CYPRESS_dhis2InstanceVersion: ${{ needs.compute-dev-version.outputs.version }}
+                  CYPRESS_dhis2Username: ${{ secrets.username }}
+                  CYPRESS_dhis2Password: ${{ secrets.password }}
+                  CYPRESS_networkMode: live
+                  GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/cypress/helpers/dimensions.js b/cypress/helpers/dimensions.js
index 584bf857f..efcef8233 100644
--- a/cypress/helpers/dimensions.js
+++ b/cypress/helpers/dimensions.js
@@ -24,6 +24,11 @@ const selectProgramAndStage = ({ inputType, programName, stageName }) => {
     }
 }
 
+export const selectProgramForTE = (programName) => {
+    cy.getBySel('accessory-sidebar').contains('Choose a program').click()
+    cy.contains(programName).click()
+}
+
 export const selectEventWithProgram = ({ programName, stageName }) =>
     selectProgramAndStage({ inputType: INPUT_EVENT, programName, stageName })
 
@@ -33,6 +38,12 @@ export const selectEnrollmentWithProgram = ({ programName }) =>
         programName,
     })
 
+export const selectTrackedEntityWithType = (typeName) => {
+    cy.getBySel('input-tracked-entity').click()
+    cy.getBySel('accessory-sidebar').contains('Choose a type').click()
+    cy.contains(typeName).click()
+}
+
 export const openInputSidebar = () => {
     cy.getBySel('main-sidebar').contains('Input:').click()
     cy.getBySel('input-panel').should('be.visible')
@@ -40,7 +51,6 @@ export const openInputSidebar = () => {
 
 export const openProgramDimensionsSidebar = () => {
     cy.getBySel('main-sidebar').contains('Program dimensions').click()
-    cy.getBySel('program-dimensions').should('be.visible')
 }
 
 export const openDimension = (dimensionName) => {
@@ -67,6 +77,9 @@ export const clickAddRemoveProgramDimension = (label) =>
 export const clickAddRemoveProgramDataDimension = (label) =>
     clickAddRemoveDimension('program-dimensions-list', label)
 
+export const clickAddRemoveTrackedEntityTypeDimensions = (label) =>
+    clickAddRemoveDimension('tracked-entity-dimensions-list', label)
+
 const selectProgramDimensions = ({
     inputType,
     programName,
@@ -105,6 +118,19 @@ export const selectEnrollmentWithProgramDimensions = ({
         dimensions,
     })
 
+export const selectTrackedEntityWithTypeAndProgramDimensions = ({
+    typeName,
+    programName,
+    dimensions,
+}) => {
+    selectTrackedEntityWithType(typeName)
+    openProgramDimensionsSidebar()
+    selectProgramForTE(programName)
+    dimensions.forEach((dimensionName) => {
+        clickAddRemoveProgramDataDimension(dimensionName)
+    })
+}
+
 const disabledOpacity = { prop: 'opacity', value: '0.5' }
 const disabledCursor = { prop: 'cursor', value: 'not-allowed' }
 
diff --git a/cypress/helpers/fileMenu.js b/cypress/helpers/fileMenu.js
index eb68ea0c3..a2415e8f6 100644
--- a/cypress/helpers/fileMenu.js
+++ b/cypress/helpers/fileMenu.js
@@ -1,3 +1,4 @@
+import { EXTENDED_TIMEOUT } from '../support/util.js'
 import { clearInput, typeInput, clearTextarea, typeTextarea } from './common.js'
 
 export const ITEM_NEW = 'file-menu-new'
@@ -68,3 +69,15 @@ export const renameVisualization = (name, description) => {
 
     cy.getBySel('file-menu-rename-modal-rename').click()
 }
+
+export const openAOByName = (name) => {
+    cy.getBySel('dhis2-analytics-hovermenubar').contains('File').click()
+
+    cy.getBySel(ITEM_OPEN).click()
+
+    typeInput('open-file-dialog-modal-name-filter', name)
+
+    cy.getBySel('open-file-dialog-modal', EXTENDED_TIMEOUT)
+        .contains(name, EXTENDED_TIMEOUT)
+        .click()
+}
diff --git a/cypress/helpers/layout.js b/cypress/helpers/layout.js
index 443947146..4bf160bfd 100644
--- a/cypress/helpers/layout.js
+++ b/cypress/helpers/layout.js
@@ -27,21 +27,29 @@ export const expectAxisToNotHaveDimension = (axisId, dimensionId) => {
 export const assertTooltipContainsEntries = (entries) =>
     entries.forEach((entry) => cy.getBySel('tooltip-content').contains(entry))
 
-export const assertChipContainsText = (dimensionName, suffix) => {
-    if (suffix) {
+export const assertChipContainsText = (primary, items, secondary) => {
+    if (items) {
         cy.getBySelLike('layout-chip')
-            .containsExact(dimensionName, EXTENDED_TIMEOUT)
+            .containsExact(primary, EXTENDED_TIMEOUT)
             .parent()
-            .findBySelLike('chip-suffix')
-            .contains(suffix, EXTENDED_TIMEOUT)
+            .parent()
+            .findBySelLike('chip-items')
+            .contains(items, EXTENDED_TIMEOUT)
     } else {
         cy.getBySelLike('layout-chip')
-            .containsExact(dimensionName, EXTENDED_TIMEOUT)
+            .containsExact(primary, EXTENDED_TIMEOUT)
+            .parent()
             .parent()
-            .findBySelLike('chip-suffix')
+            .findBySelLike('chip-items')
             .should('not.exist')
     }
+    if (secondary) {
+        cy.getBySelLike('layout-chip').containsExact(
+            secondary,
+            EXTENDED_TIMEOUT
+        )
+    }
     cy.getBySelLike('layout-chip')
-        .containsExact(dimensionName, EXTENDED_TIMEOUT)
+        .containsExact(primary, EXTENDED_TIMEOUT)
         .trigger('mouseover')
 }
diff --git a/cypress/helpers/menubar.js b/cypress/helpers/menubar.js
index b490ea75c..452fccd37 100644
--- a/cypress/helpers/menubar.js
+++ b/cypress/helpers/menubar.js
@@ -20,17 +20,17 @@ export const clickMenubarOptionsButton = () =>
 
 export const openDataOptionsModal = () => {
     clickMenubarOptionsButton()
-    return cy.getBySel('options-menu-list').contains('Data').click()
+    cy.getBySel('options-menu-list').contains('Data').click()
 }
 
 export const openStyleOptionsModal = () => {
     clickMenubarOptionsButton()
-    return cy.getBySel('options-menu-list').contains('Style').click()
+    cy.getBySel('options-menu-list').contains('Style').click()
 }
 
 export const openLegendOptionsModal = () => {
     clickMenubarOptionsButton()
-    return cy.getBySel('options-menu-list').contains('Legend').click()
+    cy.getBySel('options-menu-list').contains('Legend').click()
 }
 
 export const clickMenubarInterpretationsButton = () =>
diff --git a/cypress/helpers/orgUnit.js b/cypress/helpers/orgUnit.js
index aa2a7bf7b..d20c2783a 100644
--- a/cypress/helpers/orgUnit.js
+++ b/cypress/helpers/orgUnit.js
@@ -1,6 +1,6 @@
 import { EXTENDED_TIMEOUT } from '../support/util.js'
 
-const orgUnitModalEl = 'fixed-dimension-ou-modal'
+const orgUnitModalEl = 'ou-modal'
 const levelSelectEl = 'org-unit-level-select'
 const levelSelectOptionEl = 'org-unit-level-select-option'
 const groupSelectEl = 'org-unit-group-select'
@@ -12,12 +12,12 @@ const orgUnitTreeNodeSelectEl = '[type="checkbox"]'
 const orgUnitTreeNodeToggleEl = 'org-unit-tree-node-toggle'
 
 export const clickOrgUnitDimensionModalUpdateButton = () =>
-    cy.getBySel(`${orgUnitModalEl}-action-confirm`).click()
+    cy.getBySelLike(`${orgUnitModalEl}-action-confirm`).click()
 
 export const openOuDimension = () => cy.getBySelLike('layout-chip-ou').click()
 
 export const expectOrgUnitDimensionModalToBeVisible = () =>
-    cy.getBySel(orgUnitModalEl).should('be.visible')
+    cy.getBySelLike(orgUnitModalEl).should('be.visible')
 
 export const expectOrgUnitDimensionToNotBeLoading = () =>
     cy
@@ -84,24 +84,24 @@ export const toggleOrgUnitGroup = (name) => {
 }
 
 export const selectUserOrgUnit = (name) => {
-    cy.getBySel(orgUnitModalEl)
+    cy.getBySelLike(orgUnitModalEl)
         .contains(name)
         .find('[type="checkbox"]')
         .should('not.be.checked')
-    cy.getBySel(orgUnitModalEl).contains(name).click()
-    cy.getBySel(orgUnitModalEl)
+    cy.getBySelLike(orgUnitModalEl).contains(name).click()
+    cy.getBySelLike(orgUnitModalEl)
         .contains(name)
         .find('[type="checkbox"]')
         .should('be.checked')
 }
 
 export const deselectUserOrgUnit = (name) => {
-    cy.getBySel(orgUnitModalEl)
+    cy.getBySelLike(orgUnitModalEl)
         .contains(name)
         .find('[type="checkbox"]')
         .should('be.checked')
-    cy.getBySel(orgUnitModalEl).contains(name).click()
-    cy.getBySel(orgUnitModalEl)
+    cy.getBySelLike(orgUnitModalEl).contains(name).click()
+    cy.getBySelLike(orgUnitModalEl)
         .contains(name)
         .find('[type="checkbox"]')
         .should('not.be.checked')
diff --git a/cypress/helpers/period.js b/cypress/helpers/period.js
index 562b1b64c..c99a69437 100644
--- a/cypress/helpers/period.js
+++ b/cypress/helpers/period.js
@@ -7,11 +7,15 @@ const openPeriod = (label) => {
     }
 }
 
-const selectFixedPeriod = ({ label, period }) => {
+const DEFAULT_FIXED_PERIOD_TYPE = 'Monthly'
+const selectFixedPeriod = ({ label, period, selected }) => {
+    // open the period modal in the fixed period view
     openPeriod(label)
     cy.contains('Choose from presets').click()
     cy.contains('Fixed periods').click()
-    if (period.type) {
+
+    // change period type if applicable
+    if (period.type && period.type !== DEFAULT_FIXED_PERIOD_TYPE) {
         cy.getBySel(
             'period-dimension-fixed-period-filter-period-type-content'
         ).click()
@@ -21,12 +25,30 @@ const selectFixedPeriod = ({ label, period }) => {
             .contains(period.type)
             .click()
     }
+
+    // select the year and the period
     cy.getBySel('period-dimension-fixed-period-filter-year-content')
         .clear()
         .type(period.year)
-    cy.getBySel('period-dimension-transfer-option-content')
+    cy.getBySel('period-dimension-transfer-sourceoptions')
+        .findBySel('period-dimension-transfer-option-content')
         .contains(period.name)
         .dblclick()
+
+    cy.getBySel('period-dimension-transfer-pickedoptions').contains(period.name)
+    cy.getBySel('period-dimension-transfer-sourceoptions')
+        .contains(period.name)
+        .should('not.exist')
+
+    // verify that a previously selected period is visible in the picked options and not in the source options
+    if (selected) {
+        cy.getBySel('period-dimension-transfer-pickedoptions')
+            .containsExact(selected.name)
+            .should('be.visible')
+        cy.getBySel('period-dimension-transfer-sourceoptions')
+            .contains(selected.name)
+            .should('not.exist')
+    }
     cy.getBySel('period-dimension-modal-action-confirm').click()
 }
 
diff --git a/cypress/integration/conditions/alphanumericConditions.cy.js b/cypress/integration/conditions/alphanumericConditions.cy.js
index c22f86280..44655fee1 100644
--- a/cypress/integration/conditions/alphanumericConditions.cy.js
+++ b/cypress/integration/conditions/alphanumericConditions.cy.js
@@ -1,3 +1,4 @@
+import { DIMENSION_ID_ORGUNIT } from '@dhis2/analytics'
 import { DIMENSION_ID_EVENT_DATE } from '../../../src/modules/dimensionConstants.js'
 import {
     E2E_PROGRAM,
@@ -11,16 +12,27 @@ import {
     TEST_REL_PE_THIS_YEAR,
 } from '../../data/index.js'
 import {
+    clickAddRemoveTrackedEntityTypeDimensions,
     openDimension,
     openProgramDimensionsSidebar,
     selectEventWithProgram,
     selectEventWithProgramDimensions,
+    selectTrackedEntityWithType,
 } from '../../helpers/dimensions.js'
 import {
     assertChipContainsText,
     assertTooltipContainsEntries,
 } from '../../helpers/layout.js'
 import { clickMenubarUpdateButton } from '../../helpers/menubar.js'
+import {
+    clickOrgUnitDimensionModalUpdateButton,
+    deselectUserOrgUnit,
+    expectOrgUnitDimensionModalToBeVisible,
+    expectOrgUnitDimensionToNotBeLoading,
+    openOrgUnitTreeItem,
+    openOuDimension,
+    selectOrgUnitTreeItem,
+} from '../../helpers/orgUnit.js'
 import {
     getCurrentYearStr,
     selectRelativePeriod,
@@ -33,27 +45,25 @@ import {
 } from '../../helpers/table.js'
 
 const event = E2E_PROGRAM
-const dimensionName = TEST_DIM_TEXT
 const periodLabel = event[DIMENSION_ID_EVENT_DATE]
-const stageName = 'Stage 1 - Repeatable'
-const currentYear = getCurrentYearStr()
 
-const setUpTable = () => {
-    selectEventWithProgramDimensions({ ...event, dimensions: [dimensionName] })
+const currentYear = getCurrentYearStr()
 
-    selectRelativePeriod({
-        label: periodLabel,
-        period: TEST_REL_PE_THIS_YEAR,
+/*
+    // one way to make sure that conditions work for TE is to simply duplicate the tests we have today and adapt them to TE, here's a quick plan for that:
+    // TODO: make a copy of the "describe('text conditions..." below
+    // TODO: change the beforeEach to include this instead:
+    selectTrackedEntityWithTypeAndProgramDimensions({
+        typeName: 'Person',
+        ...event,
+        dimensions: [dimensionName],
     })
+    // TODO: add period selection here once it's supported / before merging this to master!
+    // TODO: adapt the results of each test to match the result from tracked entity
 
-    clickMenubarUpdateButton()
-
-    expectTableToBeVisible()
-
-    assertChipContainsText(dimensionName, 'all')
-}
-
-const addConditions = (conditions) => {
+    // TODO: do all of the above for the other types of conditions
+*/
+const addConditions = (conditions, dimensionName) => {
     cy.getBySelLike('layout-chip').contains(dimensionName).click()
     conditions.forEach(({ conditionName, value, useCaseSensitive }, index) => {
         cy.getBySel('button-add-condition').click()
@@ -79,19 +89,39 @@ const addConditions = (conditions) => {
 
 /* This test doesn't look like it needs `testIsolation: false`
  * but start failing once this is removed */
-describe('text conditions', { testIsolation: false }, () => {
+describe('text conditions (event)', { testIsolation: false }, () => {
+    const dimensionName = TEST_DIM_TEXT
+    const stageName = 'Stage 1 - Repeatable'
     const LONG_TEXT =
         'Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
 
     beforeEach(() => {
         goToStartPage()
-        setUpTable()
+
+        selectEventWithProgramDimensions({
+            ...event,
+            dimensions: [dimensionName],
+        })
+
+        selectRelativePeriod({
+            label: periodLabel,
+            period: TEST_REL_PE_THIS_YEAR,
+        })
+
+        clickMenubarUpdateButton()
+
+        expectTableToBeVisible()
+
+        assertChipContainsText(dimensionName, 'all')
     })
 
     it('exactly', () => {
         const TEST_TEXT = 'Text A'
 
-        addConditions([{ conditionName: 'exactly', value: TEST_TEXT }])
+        addConditions(
+            [{ conditionName: 'exactly', value: TEST_TEXT }],
+            dimensionName
+        )
 
         expectTableToMatchRows([TEST_TEXT])
 
@@ -103,7 +133,10 @@ describe('text conditions', { testIsolation: false }, () => {
     it('is not', () => {
         const TEST_TEXT = 'Text A'
 
-        addConditions([{ conditionName: 'is not', value: TEST_TEXT }])
+        addConditions(
+            [{ conditionName: 'is not', value: TEST_TEXT }],
+            dimensionName
+        )
 
         expectTableToMatchRows([
             LONG_TEXT,
@@ -122,12 +155,15 @@ describe('text conditions', { testIsolation: false }, () => {
     it('contains', () => {
         const TEST_TEXT = 'T'
 
-        addConditions([
-            {
-                conditionName: 'contains',
-                value: TEST_TEXT,
-            },
-        ])
+        addConditions(
+            [
+                {
+                    conditionName: 'contains',
+                    value: TEST_TEXT,
+                },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows([LONG_TEXT, 'Text A', 'Text A-2', 'Text E'])
 
@@ -139,13 +175,16 @@ describe('text conditions', { testIsolation: false }, () => {
     it('contains (case-sensitive)', () => {
         const TEST_TEXT = 'T'
 
-        addConditions([
-            {
-                conditionName: 'contains',
-                value: TEST_TEXT,
-                useCaseSensitive: true,
-            },
-        ])
+        addConditions(
+            [
+                {
+                    conditionName: 'contains',
+                    value: TEST_TEXT,
+                    useCaseSensitive: true,
+                },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows(['Text A', 'Text A-2', 'Text E'])
 
@@ -157,12 +196,15 @@ describe('text conditions', { testIsolation: false }, () => {
     it('does not contain', () => {
         const TEST_TEXT = 'T'
 
-        addConditions([
-            {
-                conditionName: 'does not contain',
-                value: TEST_TEXT,
-            },
-        ])
+        addConditions(
+            [
+                {
+                    conditionName: 'does not contain',
+                    value: TEST_TEXT,
+                },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows([
             `${currentYear}-03-01`, // empty row, use value in date column
@@ -179,11 +221,14 @@ describe('text conditions', { testIsolation: false }, () => {
     })
 
     it('is empty / null', () => {
-        addConditions([
-            {
-                conditionName: 'is empty / null',
-            },
-        ])
+        addConditions(
+            [
+                {
+                    conditionName: 'is empty / null',
+                },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows([`${currentYear}-03-01`, `${currentYear}-02-01`]) // empty row, use value in date column
 
@@ -193,11 +238,14 @@ describe('text conditions', { testIsolation: false }, () => {
     })
 
     it('is not empty / not null', () => {
-        addConditions([
-            {
-                conditionName: 'is not empty / not null',
-            },
-        ])
+        addConditions(
+            [
+                {
+                    conditionName: 'is not empty / not null',
+                },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows([
             LONG_TEXT,
@@ -213,10 +261,13 @@ describe('text conditions', { testIsolation: false }, () => {
     })
 
     it('2 conditions: contains + is not', () => {
-        addConditions([
-            { conditionName: 'contains', value: 'T' },
-            { conditionName: 'is not', value: 'Text A-2' },
-        ])
+        addConditions(
+            [
+                { conditionName: 'contains', value: 'T' },
+                { conditionName: 'is not', value: 'Text A-2' },
+            ],
+            dimensionName
+        )
 
         expectTableToMatchRows([LONG_TEXT, 'Text A', 'Text E'])
 
@@ -225,6 +276,185 @@ describe('text conditions', { testIsolation: false }, () => {
         assertTooltipContainsEntries([stageName, 'Contains: ', 'Is not: '])
     })
 })
+describe(['>=41'], 'text conditions (TE)', { testIsolation: false }, () => {
+    const dimensionName = 'First Name'
+
+    beforeEach(() => {
+        // set up a TE LL with some dimensions
+        goToStartPage()
+        selectTrackedEntityWithType('Malaria Entity')
+        cy.getBySel('main-sidebar')
+            .contains('Malaria Entity dimensions')
+            .click()
+        clickAddRemoveTrackedEntityTypeDimensions(dimensionName)
+        // select a second dimension that can be verified if the first dimension has an emtpy value
+        clickAddRemoveTrackedEntityTypeDimensions('System Case ID')
+
+        // change org unit to limit the data
+        openOuDimension(DIMENSION_ID_ORGUNIT)
+        expectOrgUnitDimensionModalToBeVisible()
+        expectOrgUnitDimensionToNotBeLoading()
+        deselectUserOrgUnit('User organisation unit')
+        openOrgUnitTreeItem('Bo')
+        openOrgUnitTreeItem('Badjia')
+        selectOrgUnitTreeItem('Njandama MCHP')
+        clickOrgUnitDimensionModalUpdateButton()
+
+        // assert that the table is visible and that the layout chip is present
+        expectTableToBeVisible()
+        assertChipContainsText(dimensionName, 'all')
+    })
+
+    it('exactly', () => {
+        const TEST_TEXT = 'Angus'
+
+        addConditions(
+            [{ conditionName: 'exactly', value: TEST_TEXT }],
+            dimensionName
+        )
+
+        expectTableToMatchRows([TEST_TEXT])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Exactly: ${TEST_TEXT}`])
+    })
+
+    it('is not', () => {
+        const TEST_TEXT = 'Angus'
+
+        addConditions(
+            [{ conditionName: 'is not', value: TEST_TEXT }],
+            dimensionName
+        )
+
+        expectTableToMatchRows([
+            'Mark',
+            'YYX928443', // empty row, use value in another column
+            'BGD242352', // empty row, use value in another column
+            'beleb',
+        ])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Is not: ${TEST_TEXT}`])
+    })
+
+    it('contains', () => {
+        const TEST_TEXT = 'A'
+
+        addConditions(
+            [
+                {
+                    conditionName: 'contains',
+                    value: TEST_TEXT,
+                },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['Angus', 'Mark'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Contains: ${TEST_TEXT}`])
+    })
+
+    it('contains (case-sensitive)', () => {
+        const TEST_TEXT = 'a'
+
+        addConditions(
+            [
+                {
+                    conditionName: 'contains',
+                    value: TEST_TEXT,
+                    useCaseSensitive: true,
+                },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['Mark'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Contains: ${TEST_TEXT}`])
+    })
+
+    it('does not contain', () => {
+        const TEST_TEXT = 'A'
+
+        addConditions(
+            [
+                {
+                    conditionName: 'does not contain',
+                    value: TEST_TEXT,
+                },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows([
+            'beleb',
+            'YYX928443', // empty row, use value in another column
+            'BGD242352', // empty row, use value in another column
+        ])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Does not contain: ${TEST_TEXT}`])
+    })
+
+    it('is empty / null', () => {
+        addConditions(
+            [
+                {
+                    conditionName: 'is empty / null',
+                },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['YYX928443', 'BGD242352']) //// empty row, use value in another column
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Is empty / null`])
+    })
+
+    it('is not empty / not null', () => {
+        addConditions(
+            [
+                {
+                    conditionName: 'is not empty / not null',
+                },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['Angus', 'Mark', 'beleb'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries([`Is not empty / not null`])
+    })
+
+    it('2 conditions: contains + is not', () => {
+        addConditions(
+            [
+                { conditionName: 'contains', value: 'A' },
+                { conditionName: 'is not', value: 'Mark' },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['Angus'])
+
+        assertChipContainsText(dimensionName, 2)
+
+        assertTooltipContainsEntries(['Contains: ', 'Is not: '])
+    })
+})
 /* This test doesn't look like it needs `testIsolation: false`
  * but start failing once this is removed */
 describe('alphanumeric types', { testIsolation: false }, () => {
diff --git a/cypress/integration/conditions/booleanConditions.cy.js b/cypress/integration/conditions/booleanConditions.cy.js
index 461562bd9..617ef1a02 100644
--- a/cypress/integration/conditions/booleanConditions.cy.js
+++ b/cypress/integration/conditions/booleanConditions.cy.js
@@ -27,6 +27,8 @@ const event = E2E_PROGRAM
 const periodLabel = event[DIMENSION_ID_EVENT_DATE]
 const stageName = 'Stage 1 - Repeatable'
 
+// TODO: implement these tests for TE as soon as the backend returns 1 / 0 instead of "true" / "false"
+
 const setUpTable = (dimensionName) => {
     selectEventWithProgramDimensions({ ...event, dimensions: [dimensionName] })
 
diff --git a/cypress/integration/conditions/numericConditions.cy.js b/cypress/integration/conditions/numericConditions.cy.js
index eab79fa8e..b4a2ce17e 100644
--- a/cypress/integration/conditions/numericConditions.cy.js
+++ b/cypress/integration/conditions/numericConditions.cy.js
@@ -1,3 +1,4 @@
+import { DIMENSION_ID_ORGUNIT } from '@dhis2/analytics'
 import { DIMENSION_ID_EVENT_DATE } from '../../../src/modules/dimensionConstants.js'
 import {
     E2E_PROGRAM,
@@ -13,16 +14,27 @@ import {
     TEST_DIM_WITH_PRESET,
 } from '../../data/index.js'
 import {
+    clickAddRemoveTrackedEntityTypeDimensions,
     openDimension,
     openProgramDimensionsSidebar,
     selectEventWithProgram,
     selectEventWithProgramDimensions,
+    selectTrackedEntityWithType,
 } from '../../helpers/dimensions.js'
 import {
     assertChipContainsText,
     assertTooltipContainsEntries,
 } from '../../helpers/layout.js'
 import { clickMenubarUpdateButton } from '../../helpers/menubar.js'
+import {
+    clickOrgUnitDimensionModalUpdateButton,
+    deselectUserOrgUnit,
+    expectOrgUnitDimensionModalToBeVisible,
+    expectOrgUnitDimensionToNotBeLoading,
+    openOrgUnitTreeItem,
+    openOuDimension,
+    selectOrgUnitTreeItem,
+} from '../../helpers/orgUnit.js'
 import {
     getPreviousYearStr,
     getCurrentYearStr,
@@ -44,21 +56,6 @@ const event = E2E_PROGRAM
 const periodLabel = event[DIMENSION_ID_EVENT_DATE]
 const stageName = 'Stage 1 - Repeatable'
 
-const setUpTable = (dimensionName, period) => {
-    selectEventWithProgramDimensions({ ...event, dimensions: [dimensionName] })
-
-    selectRelativePeriod({
-        label: periodLabel,
-        period,
-    })
-
-    clickMenubarUpdateButton()
-
-    expectTableToBeVisible()
-
-    assertChipContainsText(dimensionName, 'all')
-}
-
 const addConditions = (conditions, dimensionName) => {
     cy.getBySelLike('layout-chip').contains(dimensionName).click()
     conditions.forEach(({ conditionName, value }) => {
@@ -74,15 +71,8 @@ const addConditions = (conditions, dimensionName) => {
     cy.getBySel('conditions-modal').contains('Update').click()
 }
 
-/* This test doesn't look like it needs `testIsolation: false`
- * but start failing once this is removed */
-describe('number conditions', { testIsolation: false }, () => {
-    const dimensionName = TEST_DIM_NUMBER
-
-    beforeEach(() => {
-        goToStartPage()
-        setUpTable(dimensionName, TEST_REL_PE_THIS_YEAR)
-    })
+const testNumberConditions = (dimensionName, version) => {
+    const decimalNumber = version >= 41 ? '3.12' : '3.1'
 
     it('equal to', () => {
         addConditions(
@@ -136,7 +126,7 @@ describe('number conditions', { testIsolation: false }, () => {
             dimensionName
         )
 
-        expectTableToMatchRows(['11', '3.7'])
+        expectTableToMatchRows(['11', decimalNumber])
 
         assertChipContainsText(dimensionName, 1)
 
@@ -149,7 +139,7 @@ describe('number conditions', { testIsolation: false }, () => {
             dimensionName
         )
 
-        expectTableToMatchRows(['11', '12', '3.7'])
+        expectTableToMatchRows(['11', '12', decimalNumber])
 
         assertChipContainsText(dimensionName, 1)
 
@@ -166,7 +156,7 @@ describe('number conditions', { testIsolation: false }, () => {
         )
 
         expectTableToMatchRows([
-            '3.7',
+            decimalNumber,
             '11',
             `${currentYear}-01-01`, // empty row, use value in date column
             '2 000 000',
@@ -202,7 +192,7 @@ describe('number conditions', { testIsolation: false }, () => {
         )
 
         expectTableToMatchRows([
-            '3.7',
+            decimalNumber,
             '11',
             '12',
             '2 000 000',
@@ -234,6 +224,240 @@ describe('number conditions', { testIsolation: false }, () => {
             'Less than (<): 13',
         ])
     })
+}
+
+const prepareNumberConditions = (dimensionName) => {
+    goToStartPage()
+    selectEventWithProgramDimensions({
+        ...event,
+        dimensions: [dimensionName],
+    })
+
+    selectRelativePeriod({
+        label: periodLabel,
+        period: TEST_REL_PE_THIS_YEAR,
+    })
+
+    clickMenubarUpdateButton()
+
+    expectTableToBeVisible()
+
+    assertChipContainsText(dimensionName, 'all')
+}
+
+/* This test doesn't look like it needs `testIsolation: false`
+ * but start failing once this is removed */
+describe(['<41'], 'number conditions (event)', { testIsolation: false }, () => {
+    const dimensionName = TEST_DIM_NUMBER
+
+    beforeEach(() => {
+        prepareNumberConditions(dimensionName)
+    })
+
+    testNumberConditions(dimensionName, 40)
+})
+describe(
+    ['>=41'],
+    'number conditions (event)',
+    { testIsolation: false },
+    () => {
+        const dimensionName = TEST_DIM_NUMBER
+
+        beforeEach(() => {
+            prepareNumberConditions(dimensionName)
+        })
+
+        testNumberConditions(dimensionName, 41)
+    }
+)
+
+describe(['>=41'], 'number conditions (TE)', { testIsolation: false }, () => {
+    const dimensionName = 'Age (years)'
+
+    beforeEach(() => {
+        // set up a TE LL with a dimension
+        goToStartPage()
+        selectTrackedEntityWithType('Malaria Entity')
+        cy.getBySel('main-sidebar')
+            .contains('Malaria Entity dimensions')
+            .click()
+        clickAddRemoveTrackedEntityTypeDimensions(dimensionName)
+        clickMenubarUpdateButton()
+
+        // expect the table to be visible and the dimension chip to be present
+        expectTableToBeVisible()
+        assertChipContainsText(dimensionName, 'all')
+    })
+
+    it('equal to', () => {
+        addConditions(
+            [{ conditionName: 'equal to (=)', value: '15' }],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['15'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Equal to (=): 15'])
+    })
+
+    it('greater than', () => {
+        addConditions(
+            [{ conditionName: 'greater than (>)', value: '43' }],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['46', '64'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Greater than (>): 43'])
+    })
+
+    it('greater than or equal to', () => {
+        addConditions(
+            [{ conditionName: 'greater than or equal to', value: '43' }],
+            dimensionName
+        )
+        expectTableToMatchRows(['43', '46', '64'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Greater than or equal to (≥): 43'])
+    })
+
+    it('less than', () => {
+        addConditions(
+            [{ conditionName: 'less than (<)', value: '11' }],
+            dimensionName
+        )
+
+        expectTableToMatchRows([
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '6',
+            '9',
+            '9',
+        ])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Less than (<): 11'])
+    })
+
+    it('less than or equal to', () => {
+        addConditions(
+            [{ conditionName: 'less than or equal to', value: '11' }],
+            dimensionName
+        )
+
+        expectTableToMatchRows([
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '0',
+            '6',
+            '9',
+            '9',
+            '11',
+        ])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Less than or equal to (≤): 11'])
+    })
+
+    it('not equal to', () => {
+        openOuDimension(DIMENSION_ID_ORGUNIT)
+        expectOrgUnitDimensionModalToBeVisible()
+        expectOrgUnitDimensionToNotBeLoading()
+        deselectUserOrgUnit('User organisation unit')
+        openOrgUnitTreeItem('Bo')
+        openOrgUnitTreeItem('Badjia')
+        selectOrgUnitTreeItem('Njandama MCHP')
+        clickOrgUnitDimensionModalUpdateButton()
+
+        addConditions(
+            [{ conditionName: 'not equal to', value: '11' }],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['0', '0', '26', '36'])
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Not equal to (≠): 11'])
+    })
+
+    it('is empty / null', () => {
+        clickAddRemoveTrackedEntityTypeDimensions('System Case ID')
+
+        addConditions([{ conditionName: 'is empty / null' }], dimensionName)
+
+        expectTableToMatchRows(['GFS397135', 'VCA989272', 'PVZ270497'])
+
+        getTableDataCells()
+            .eq(1)
+            .invoke('text')
+            .invoke('trim')
+            .should('equal', '')
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Is empty / null'])
+    })
+
+    it('is not empty / not null', () => {
+        openOuDimension(DIMENSION_ID_ORGUNIT)
+        expectOrgUnitDimensionModalToBeVisible()
+        expectOrgUnitDimensionToNotBeLoading()
+        deselectUserOrgUnit('User organisation unit')
+        openOrgUnitTreeItem('Bo')
+        openOrgUnitTreeItem('Badjia')
+        selectOrgUnitTreeItem('Ngelehun CHC')
+        clickOrgUnitDimensionModalUpdateButton()
+
+        getTableRows().should('have.length', 32)
+
+        addConditions(
+            [{ conditionName: 'is not empty / not null' }],
+            dimensionName
+        )
+
+        getTableRows().should('have.length', 29)
+
+        assertChipContainsText(dimensionName, 1)
+
+        assertTooltipContainsEntries(['Is not empty / not null'])
+    })
+
+    it('2 conditions: greater than + less than', () => {
+        addConditions(
+            [
+                { conditionName: 'greater than (>)', value: '21' },
+                { conditionName: 'less than (<)', value: '24' },
+            ],
+            dimensionName
+        )
+
+        expectTableToMatchRows(['23'])
+
+        assertChipContainsText(dimensionName, 2)
+
+        assertTooltipContainsEntries([
+            'Greater than (>): 21',
+            'Less than (<): 24',
+        ])
+    })
 })
 
 /* This test doesn't look like it needs `testIsolation: false`
@@ -243,7 +467,22 @@ describe('integer', { testIsolation: false }, () => {
 
     beforeEach(() => {
         goToStartPage()
-        setUpTable(dimensionName, TEST_REL_PE_LAST_YEAR)
+
+        selectEventWithProgramDimensions({
+            ...event,
+            dimensions: [dimensionName],
+        })
+
+        selectRelativePeriod({
+            label: periodLabel,
+            period: TEST_REL_PE_LAST_YEAR,
+        })
+
+        clickMenubarUpdateButton()
+
+        expectTableToBeVisible()
+
+        assertChipContainsText(dimensionName, 'all')
     })
 
     it('integer with negative value', () => {
diff --git a/cypress/integration/createTrackedEntity.cy.js b/cypress/integration/createTrackedEntity.cy.js
new file mode 100644
index 000000000..d4ef97a1f
--- /dev/null
+++ b/cypress/integration/createTrackedEntity.cy.js
@@ -0,0 +1,246 @@
+import {
+    DIMENSION_ID_ENROLLMENT_DATE,
+    DIMENSION_ID_INCIDENT_DATE,
+    DIMENSION_ID_LAST_UPDATED,
+} from '../../src/modules/dimensionConstants.js'
+import {
+    clickAddRemoveProgramDataDimension,
+    clickAddRemoveTrackedEntityTypeDimensions,
+    openProgramDimensionsSidebar,
+    selectProgramForTE,
+    selectTrackedEntityWithType,
+} from '../helpers/dimensions.js'
+import { assertChipContainsText } from '../helpers/layout.js'
+import { clickMenubarUpdateButton } from '../helpers/menubar.js'
+import { selectFixedPeriod, getCurrentYearStr } from '../helpers/period.js'
+import { goToStartPage } from '../helpers/startScreen.js'
+import { expectTableToBeVisible } from '../helpers/table.js'
+
+describe(['>=41'], 'tracked entity', () => {
+    beforeEach(() => {
+        goToStartPage()
+    })
+    it('creates a line list with dimensions', () => {
+        const program = {
+            programName: 'Child Programme',
+            [DIMENSION_ID_ENROLLMENT_DATE]: 'Date of enrollment',
+            [DIMENSION_ID_INCIDENT_DATE]: 'Date of birth',
+            [DIMENSION_ID_LAST_UPDATED]: 'Last updated on',
+            id: 'IpHINAT79UW',
+        }
+        const entityDimensionName = 'City'
+        const programDataDimensionName = 'MCH Infant Weight (g)'
+        const periodLabel = program[DIMENSION_ID_ENROLLMENT_DATE]
+
+        // verify that e.g. the "Person dimensions" button is hidden
+        cy.getBySel('tracked-entity-button').should('not.exist')
+        cy.getBySel('main-sidebar')
+            .contains('Person dimensions')
+            .should('not.exist')
+
+        // TODO: check that reg ou and reg date aren't shown !
+
+        // switch to Tracked entity and select a type
+        selectTrackedEntityWithType('Person')
+
+        cy.getBySel('input-panel-button-subtitle').contains('Person')
+
+        // TODO: check that reg ou and reg date are shown !
+
+        // add a TET dimension
+        cy.getBySel('main-sidebar').contains('Person dimensions').click()
+        cy.getBySel('tracked-entity-dimensions-list')
+            .children()
+            .should('have.length', 50)
+        clickAddRemoveTrackedEntityTypeDimensions(entityDimensionName)
+
+        // select a program and add program dimensions
+        openProgramDimensionsSidebar()
+
+        selectProgramForTE(program.programName)
+
+        // Check the correct time dimensions are displayed, and with program/stage specific name
+        cy.getBySel(`dimension-item-${program.id}.enrollmentDate`).contains(
+            program[DIMENSION_ID_ENROLLMENT_DATE]
+        )
+        cy.getBySel(`dimension-item-${program.id}.incidentDate`).contains(
+            program[DIMENSION_ID_INCIDENT_DATE]
+        )
+        cy.getBySel('dimension-item-lastUpdated').contains(
+            program[DIMENSION_ID_LAST_UPDATED]
+        )
+        cy.getBySel('dimension-item-eventDate').should('not.exist')
+        cy.getBySel('dimension-item-scheduledDate').should('not.exist')
+
+        // Add a program data dimension
+        clickAddRemoveProgramDataDimension(programDataDimensionName)
+
+        // Adding time dimensions
+        const firstQuarterThisYear = {
+            type: 'Quarterly',
+            year: getCurrentYearStr(),
+            name: `January - March ${getCurrentYearStr()}`,
+        }
+        const secondQuarterThisYear = {
+            type: 'Quarterly',
+            year: getCurrentYearStr(),
+            name: `April - June ${getCurrentYearStr()}`,
+        }
+
+        // Add the first time dimension
+        selectFixedPeriod({
+            label: periodLabel,
+            period: firstQuarterThisYear,
+        })
+
+        // Check the time dimension chip and tooltip content
+        cy.getBySelLike('layout-chip')
+            .contains(periodLabel)
+            .trigger('mouseover')
+        cy.getBySel('layout-chip-tooltip-content').contains(
+            firstQuarterThisYear.name
+        )
+        cy.getBySelLike('layout-chip').contains(periodLabel).trigger('mouseout')
+        cy.getBySel('layout-chip-tooltip-content').should('not.exist')
+
+        // Add another time dimension
+        selectFixedPeriod({
+            label: periodLabel,
+            period: secondQuarterThisYear,
+            selected: firstQuarterThisYear,
+        })
+
+        // Check the time dimension chip and tooltip content for the new content
+        cy.getBySelLike('layout-chip')
+            .contains(periodLabel)
+            .trigger('mouseover')
+        cy.getBySel('layout-chip-tooltip-content').contains(
+            `Program: ${program.programName}`
+        )
+        cy.getBySel('layout-chip-tooltip-content').contains(
+            firstQuarterThisYear.name
+        )
+        cy.getBySel('layout-chip-tooltip-content').contains(
+            secondQuarterThisYear.name
+        )
+        cy.getBySelLike('layout-chip').contains(periodLabel).trigger('mouseout')
+        cy.getBySel('layout-chip-tooltip-content').should('not.exist')
+
+        // Go back to person dimensions to verify that they're still listed properly
+        cy.getBySel('main-sidebar').contains('Person dimensions').click()
+        cy.getBySel('tracked-entity-dimensions-list')
+            .children()
+            .should('have.length', 50)
+
+        clickMenubarUpdateButton()
+
+        expectTableToBeVisible()
+
+        assertChipContainsText(entityDimensionName, 'all')
+    })
+    it('creates a line list without dimensions', () => {
+        // verify that a TE line list can be created without making any program related selections (or adding any dimensions)
+        selectTrackedEntityWithType('Person')
+        clickMenubarUpdateButton()
+        expectTableToBeVisible()
+    })
+    it('displays correct dimension names and suffixes', () => {
+        // TODO: Test the following:
+        /*
+            Registration org.unit - always has the same name, no suffix
+            Person dimensions - no suffix
+            Your dimensions - no suffix
+            Organisation unit - always suffixed with program name
+            Program status - always suffixed with program name
+            Time dimensions - only suffixed with program name if there are duplicates
+            Program indicator - no suffix
+            Data elements
+                no duplicates - no suffix
+                duplicates within the program - suffixed with stage name
+                duplicates between different programs - suffixed with the program name
+
+        */
+    })
+    //runTests()
+})
+
+describe(['<41'], 'tracked entity', () => {
+    it("is hidden and doesn't show up", () => {
+        goToStartPage()
+        // verify that e.g. the "Person dimensions" button doesn't exist
+        cy.getBySel('tracked-entity-button').should('not.exist')
+        // verify that the TE input option doesn't exist
+        cy.getBySel('input-tracked-entity').should('not.exist')
+    })
+})
+
+// const runTests = () => {
+//     it('creates an tracked entity line list', () => {
+//         // check the number of columns
+//         getTableHeaderCells().its('length').should('equal', 3)
+
+//         // check that there is at least 1 row
+//         getTableRows().its('length').should('be.gte', 1)
+
+//         // check the column headers in the table
+//         getTableHeaderCells().contains('Organisation unit').should('be.visible')
+//         getTableHeaderCells().contains(entityDimensionName).should('be.visible')
+//         getTableHeaderCells().contains(periodLabel).should('be.visible')
+
+//         //check the chips in the layout
+//         assertChipContainsText('Organisation unit', 1)
+
+//         assertChipContainsText(entityDimensionName, 'all')
+
+//         assertChipContainsText(periodLabel, 1)
+//     })
+
+//     it('moves a dimension to filter', () => {
+//         cy.intercept('**/api/*/analytics/**').as('getAnalytics')
+
+//         // sort on enrollment date column
+//         getTableHeaderCells().find(`button[title*="${periodLabel}"]`).click()
+
+//         // verify that the analytics request contains "asc" for enrollment date field
+//         cy.wait('@getAnalytics').then(({ request }) => {
+//             const url = new URL(request.url)
+
+//             expect(url.searchParams.has('asc')).to.be.true
+//             expect(url.searchParams.get('asc')).to.equal(
+//                 DIMENSION_ID_ENROLLMENT_DATE.toLowerCase()
+//             )
+//         })
+
+//         // move date from "Columns" to "Filter"
+//         cy.getBySel('columns-axis')
+//             .findBySel('dimension-menu-button-enrollmentDate')
+//             .click()
+//         cy.contains('Move to Filter').click()
+
+//         clickMenubarUpdateButton()
+
+//         // verify that the analytics request does not contain "asc"
+//         // the sorting needs to be reset when a dimension used to sort is removed from "Columns"
+//         cy.wait('@getAnalytics').then(({ request }) => {
+//             const url = new URL(request.url)
+
+//             expect(url.searchParams.has('asc')).to.be.false
+//         })
+
+//         // check the number of columns
+//         getTableHeaderCells().its('length').should('equal', 2)
+
+//         // check that there is at least 1 row in the table
+//         getTableRows().its('length').should('be.gte', 1)
+
+//         // check the column headers in the table
+//         getTableHeaderCells().contains('Organisation unit').should('be.visible')
+//         getTableHeaderCells().contains(entityDimensionName).should('be.visible')
+//         getTableHeaderCells().contains(periodLabel).should('not.exist')
+
+//         //check the chips in the layout
+//         assertChipContainsText('Organisation unit', 1)
+//         assertChipContainsText(entityDimensionName, 'all')
+//         assertChipContainsText(periodLabel, 1)
+//     })
+// }
diff --git a/cypress/integration/download.cy.js b/cypress/integration/download.cy.js
index ecd4dc198..fabcc9eeb 100644
--- a/cypress/integration/download.cy.js
+++ b/cypress/integration/download.cy.js
@@ -2,6 +2,7 @@ import { E2E_PROGRAM } from '../data/index.js'
 import {
     selectEnrollmentWithProgram,
     selectEventWithProgram,
+    selectTrackedEntityWithType,
 } from '../helpers/dimensions.js'
 import { clickMenubarUpdateButton } from '../helpers/menubar.js'
 import { goToStartPage } from '../helpers/startScreen.js'
@@ -47,4 +48,20 @@ describe('download', () => {
 
         downloadIsEnabled()
     })
+
+    it(
+        ['>=41'],
+        'download button enables when required dimensions are selected (TE)',
+        () => {
+            goToStartPage()
+
+            downloadIsDisabled()
+
+            selectTrackedEntityWithType('Person')
+
+            clickMenubarUpdateButton()
+
+            downloadIsEnabled()
+        }
+    )
 })
diff --git a/cypress/integration/eventStatus.cy.js b/cypress/integration/eventStatus.cy.js
index 574bd2bdc..339573afd 100644
--- a/cypress/integration/eventStatus.cy.js
+++ b/cypress/integration/eventStatus.cy.js
@@ -23,7 +23,7 @@ import {
 
 const currentYear = getCurrentYearStr()
 
-describe('event status', () => {
+describe('event status (event)', () => {
     const event = E2E_PROGRAM
     const dimensionName = 'Event status'
 
diff --git a/cypress/integration/layoutValidation.cy.js b/cypress/integration/layoutValidation.cy.js
index 358296546..4f41b46a0 100644
--- a/cypress/integration/layoutValidation.cy.js
+++ b/cypress/integration/layoutValidation.cy.js
@@ -1,55 +1,121 @@
-import { CHILD_PROGRAM } from '../data/index.js'
+import { DIMENSION_ID_ORGUNIT } from '@dhis2/analytics'
+import { E2E_PROGRAM } from '../data/index.js'
 import {
     clickAddRemoveMainDimension,
     clickAddRemoveProgramDimension,
     openProgramDimensionsSidebar,
+    selectEnrollmentWithProgram,
     selectEventWithProgram,
+    selectTrackedEntityWithType,
 } from '../helpers/dimensions.js'
 import { clickMenubarUpdateButton } from '../helpers/menubar.js'
+import {
+    clickOrgUnitDimensionModalUpdateButton,
+    deselectUserOrgUnit,
+    openOuDimension,
+} from '../helpers/orgUnit.js'
 import { goToStartPage } from '../helpers/startScreen.js'
 import { expectTableToBeVisible } from '../helpers/table.js'
 
-/* This files constains sequential tests, which means that some test steps
- * depend on a previous step. With test isolation switched on (the default setting)
- * each step (`it` block) will start off in a fresh window, and that breaks this kind
- * of test. So `testIsolation` was set to false here. */
-describe('layout validation', { testIsolation: false }, () => {
-    const trackerProgram = CHILD_PROGRAM
+describe('layout validation', () => {
+    const types = ['event', 'enrollment']
+    types.forEach((type) => {
+        it(`validates that program, columns and org unit are required (${type})`, () => {
+            const trackerProgram = E2E_PROGRAM
+
+            goToStartPage()
+
+            if (type === 'enrollment') {
+                cy.getBySel('input-enrollment').click()
+            }
+
+            clickMenubarUpdateButton()
+
+            cy.getBySel('error-container').contains('No program selected')
+
+            if (type === 'event') {
+                // select a program (without selecting stage, should auto-select)
+                selectEventWithProgram({
+                    programName: trackerProgram.programName,
+                })
+            } else {
+                selectEnrollmentWithProgram({
+                    programName: trackerProgram.programName,
+                })
+                // this will fail in january since default period is "last 12 months" and the first available enrollment is in january current year
+                // TODO: add another period if this test is run in january?
+                // or add a new enrollment in the test data for december last year?
+            }
+
+            openProgramDimensionsSidebar()
+
+            // remove org unit
+            clickAddRemoveProgramDimension('Organisation unit')
+
+            clickMenubarUpdateButton()
+
+            // columns is required
+            cy.getBySel('error-container').contains('Columns is empty')
+
+            // add something other than org unit to columns
+            clickAddRemoveMainDimension('Last updated by')
+
+            clickMenubarUpdateButton()
 
-    it('program is required', () => {
+            // org unit dimension is required
+            cy.getBySel('error-container').contains(
+                'No organisation unit selected'
+            )
+
+            // remove previously added dimension
+            clickAddRemoveMainDimension('Last updated by')
+
+            // add org unit to columns
+            clickAddRemoveProgramDimension('Organisation unit')
+
+            clickMenubarUpdateButton()
+
+            // validation succeeds when all above are provided
+            expectTableToBeVisible()
+        })
+    })
+    it(['>=41'], 'validates that type and org unit are required (TE)', () => {
         goToStartPage()
 
+        cy.getBySel('input-tracked-entity').click()
+
         clickMenubarUpdateButton()
 
-        cy.getBySel('error-container').contains('No program selected')
-    })
-    it('columns is required', () => {
-        // select a program (without selecting stage, should auto-select)
-        selectEventWithProgram({ programName: trackerProgram.programName })
+        cy.getBySel('error-container').contains(
+            'No tracked entity type selected'
+        )
 
-        openProgramDimensionsSidebar()
+        selectTrackedEntityWithType('Person')
 
         // remove org unit
-        clickAddRemoveProgramDimension('Organisation unit')
+        clickAddRemoveMainDimension('Registration org. unit')
 
         clickMenubarUpdateButton()
 
+        // columns is required
         cy.getBySel('error-container').contains('Columns is empty')
-    })
-    it('org unit dimension is required', () => {
+
         // add something other than org unit to columns
         clickAddRemoveMainDimension('Last updated by')
 
         clickMenubarUpdateButton()
 
-        cy.getBySel('error-container').contains('No organisation unit selected')
-    })
-    it('validation succeeds when all above are provided', () => {
+        // org unit isn't required
+        expectTableToBeVisible()
+
         // remove previously added dimension
         clickAddRemoveMainDimension('Last updated by')
 
-        // add org unit to columns
-        clickAddRemoveProgramDimension('Organisation unit')
+        // add org unit to columns without any items selected
+        clickAddRemoveMainDimension('Registration org. unit')
+        openOuDimension(DIMENSION_ID_ORGUNIT)
+        deselectUserOrgUnit('User organisation unit')
+        clickOrgUnitDimensionModalUpdateButton()
 
         clickMenubarUpdateButton()
 
diff --git a/cypress/integration/legendSet.cy.js b/cypress/integration/legendSet.cy.js
index 57b6f1e71..01549351b 100644
--- a/cypress/integration/legendSet.cy.js
+++ b/cypress/integration/legendSet.cy.js
@@ -9,6 +9,7 @@ import {
     openDimension,
     openProgramDimensionsSidebar,
     selectEventWithProgram,
+    selectTrackedEntityWithTypeAndProgramDimensions,
 } from '../helpers/dimensions.js'
 import { deleteVisualization, saveVisualization } from '../helpers/fileMenu.js'
 import {
@@ -44,36 +45,10 @@ const event = E2E_PROGRAM
 const dimensionName = TEST_DIM_LEGEND_SET
 const periodLabel = event[DIMENSION_ID_EVENT_DATE]
 
-/* This files constains sequential tests, which means that some test steps
- * depend on a previous step. With test isolation switched on (the default setting)
- * each step (`it` block) will start off in a fresh window, and that breaks this kind
- * of test. So `testIsolation` was set to false here. */
-describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
+describe('Options - Legend', () => {
     const defaultBackgroundColor = 'rgb(255, 255, 255)'
     const defaultTextColor = 'rgb(33, 41, 52)'
 
-    const TEST_LEGEND_AGE = {
-        name: 'Age 10y interval',
-        cells: [
-            { value: 10, color: 'rgb(255, 255, 229)' },
-            { value: 56, color: 'rgb(120, 198, 121)' },
-        ],
-    }
-
-    const TEST_LEGEND_E2E = {
-        name: 'E2E legend',
-        cells: {
-            positive: [
-                { value: 10, color: 'rgb(209, 229, 240)' },
-                { value: 56, color: 'rgb(103, 169, 207)' },
-            ],
-            negative: [
-                { value: -10, color: 'rgb(253, 219, 199)' },
-                { value: -56, color: 'rgb(239, 138, 98)' },
-            ],
-        },
-    }
-
     const assertCellsHaveDefaultColors = (selector) =>
         cy
             .getBySel('table-body')
@@ -90,7 +65,30 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
                     .should('have.css', 'color', defaultTextColor)
             })
 
-    it('no legend is applied by default', () => {
+    it(['>=39'], 'apples legend correctly (event)', () => {
+        const TEST_LEGEND_AGE = {
+            name: 'Age 10y interval',
+            cells: [
+                { value: 10, color: 'rgb(255, 255, 229)' },
+                { value: 56, color: 'rgb(120, 198, 121)' },
+            ],
+        }
+
+        const TEST_LEGEND_E2E = {
+            name: 'E2E legend',
+            cells: {
+                positive: [
+                    { value: 10, color: 'rgb(209, 229, 240)' },
+                    { value: 56, color: 'rgb(103, 169, 207)' },
+                ],
+                negative: [
+                    { value: -10, color: 'rgb(253, 219, 199)' },
+                    { value: -56, color: 'rgb(239, 138, 98)' },
+                ],
+            },
+        }
+
+        // no legend is applied by default
         goToStartPage()
 
         selectEventWithProgram(E2E_PROGRAM)
@@ -118,8 +116,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // all cells have default background and text color
         assertCellsHaveDefaultColors('tr td')
-    })
-    it('background color legend is applied (per data item)', () => {
+
+        // background color legend is applied (per data item)
         openLegendOptionsModal()
 
         cy.getBySel('options-modal-content')
@@ -148,8 +146,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // unaffected cells (date column) have default background and text color
         assertCellsHaveDefaultColors('tr td:nth-child(1)')
-    })
-    it('text color legend is applied (per data item)', () => {
+
+        // text color legend is applied (per data item)
         openLegendOptionsModal()
 
         cy.getBySel('options-modal-content').should('contain', 'Legend style')
@@ -180,11 +178,11 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // unaffected cells (date column) have default background and text color
         assertCellsHaveDefaultColors('tr td:nth-child(1)')
-    })
-    it('legend key is hidden by default', () => {
+
+        // legend key is hidden by default
         expectLegendKeyToBeHidden()
-    })
-    it('legend key displays correctly when enabled', () => {
+
+        // legend key displays correctly when enabled
         openLegendOptionsModal()
 
         expectLegendDisplayStrategyToBeByDataItem()
@@ -200,8 +198,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
         expectLegendKeyToBeVisible()
 
         expectLegendKeyToMatchLegendSets([TEST_LEGEND_AGE.name])
-    })
-    it('text color legend is applied (single legend)', () => {
+
+        // text color legend is applied (single legend)
         openLegendOptionsModal()
 
         cy.getBySel('options-modal-content').should('contain', 'Legend style')
@@ -246,8 +244,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // unaffected cells (date column) have default background and text color
         assertCellsHaveDefaultColors('tr td:nth-child(1)')
-    })
-    it('background color legend is applied (single legend)', () => {
+
+        // background color legend is applied (single legend)
         openLegendOptionsModal()
 
         cy.getBySel('options-modal-content').should('contain', 'Legend style')
@@ -278,8 +276,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // unaffected cells (date column) have default background and text color
         assertCellsHaveDefaultColors('tr td:nth-child(1)')
-    })
-    it('options can be saved and loaded', () => {
+
+        // options can be saved and loaded
         const AO_NAME = `TEST ${new Date().toLocaleString()}`
         saveVisualization(AO_NAME)
         expectAOTitleToContain(AO_NAME)
@@ -307,8 +305,8 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
         cy.getBySel('fixed-legend-set-select-content').contains(
             TEST_LEGEND_E2E.name
         )
-    })
-    it('legend is applied to negative values (per data item)', () => {
+
+        // legend is applied to negative values (per data item)
         cy.getBySel('options-modal-content')
             .contains('Use pre-defined legend per data item')
             .click()
@@ -336,16 +334,16 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
 
         // unaffected cells (date column) have default background and text color
         assertCellsHaveDefaultColors('tr td:nth-child(1)')
-    })
-    it('legend key displays correctly when two items are in use', () => {
+
+        // legend key displays correctly when two items are in use
         expectLegendKeyToBeVisible()
 
         expectLegendKeyToMatchLegendSets([
             TEST_LEGEND_AGE.name,
             TEST_LEGEND_E2E.name,
         ])
-    })
-    it('empty values do not display a legend color', () => {
+
+        // empty values do not display a legend color
         const currentYear = getCurrentYearStr()
 
         unselectAllPeriods({
@@ -380,8 +378,225 @@ describe(['>=39'], 'Options - Legend', { testIsolation: false }, () => {
             .invoke('text')
             .invoke('trim')
             .should('not.equal', '')
+
+        // saved AO can be deleted
+        deleteVisualization()
+
+        expectRouteToBeEmpty()
     })
-    it('saved AO can be deleted', () => {
+
+    it(['>=41'], 'apples legend correctly (TE)', () => {
+        const TEST_LEGEND_AGE = {
+            name: 'Age 10y interval',
+            cells: [{ value: 46, color: 'rgb(173, 221, 142)' }],
+        }
+
+        const TEST_LEGEND_E2E = {
+            name: 'E2E legend',
+            cells: [{ value: 46, color: 'rgb(103, 169, 207)' }],
+        }
+
+        // no legend is applied by default
+        goToStartPage()
+
+        selectTrackedEntityWithTypeAndProgramDimensions({
+            typeName: 'Person',
+            programName: E2E_PROGRAM.programName,
+            dimensions: [dimensionName],
+        })
+
+        // add condition to filter out empty values
+        cy.getBySelLike('layout-chip').contains(dimensionName).click()
+        cy.getBySel('button-add-condition').click()
+        cy.contains('Choose a condition type').click()
+        cy.contains('greater than (>)').click()
+        cy.getBySel('conditions-modal-content')
+            .find('input[value=""]')
+            .type('1')
+        cy.getBySel('conditions-modal').contains('Update').click()
+
+        expectTableToBeVisible()
+
+        // all cells have default background and text color
+        assertCellsHaveDefaultColors('tr td')
+
+        // background color legend is applied (per data item)
+        openLegendOptionsModal()
+
+        cy.getBySel('options-modal-content')
+            .contains('Use a legend for table cell colors')
+            .click()
+
+        cy.getBySel('options-modal-content').should('contain', 'Legend style')
+
+        expectLegendDisplayStrategyToBeByDataItem()
+
+        expectLegendDisplayStyleToBeFill()
+
+        clickOptionsModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        // affected cells have default text color and custom background color
+        TEST_LEGEND_AGE.cells.forEach((cell) =>
+            cy
+                .getBySel('table-body')
+                .contains(cell.value)
+                .should('have.css', 'color', defaultTextColor)
+                .closest('td')
+                .should('have.css', 'background-color', cell.color)
+        )
+
+        // text color legend is applied (per data item)
+        openLegendOptionsModal()
+
+        cy.getBySel('options-modal-content').should('contain', 'Legend style')
+
+        expectLegendDisplayStrategyToBeByDataItem()
+
+        expectLegendDisplayStyleToBeFill()
+
+        cy.getBySel('options-modal-content')
+            .contains('Legend changes text color')
+            .click()
+
+        expectLegendDisplayStyleToBeText()
+
+        clickOptionsModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        // affected cells have custom text color and default background color
+        TEST_LEGEND_AGE.cells.forEach((cell) =>
+            cy
+                .getBySel('table-body')
+                .contains(cell.value)
+                .should('have.css', 'color', cell.color)
+                .closest('td')
+                .should('have.css', 'background-color', defaultBackgroundColor)
+        )
+
+        // legend key is hidden by default
+        expectLegendKeyToBeHidden()
+
+        // legend key displays correctly when enabled
+        openLegendOptionsModal()
+
+        expectLegendDisplayStrategyToBeByDataItem()
+
+        cy.getBySel('options-modal-content').contains('Show legend key').click()
+
+        expectLegendKeyOptionToBeEnabled()
+
+        clickOptionsModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        expectLegendKeyToBeVisible()
+
+        expectLegendKeyToMatchLegendSets([TEST_LEGEND_AGE.name])
+
+        // text color legend is applied (single legend)
+        openLegendOptionsModal()
+
+        cy.getBySel('options-modal-content').should('contain', 'Legend style')
+
+        expectLegendDisplayStrategyToBeByDataItem()
+
+        expectLegendDisplayStyleToBeText()
+
+        cy.getBySel('options-modal-content')
+            .contains('Choose a single legend for the entire visualization')
+            .click()
+
+        cy.getBySel('options-modal-content')
+            .contains('Select from legends')
+            .click()
+
+        cy.getBySel('fixed-legend-set-option')
+            .contains(TEST_LEGEND_E2E.name)
+            .click()
+
+        cy.getBySel('options-modal-content')
+            .contains('Legend changes text color')
+            .click()
+
+        expectLegendDisplayStrategyToBeFixed()
+
+        expectLegendDisplayStyleToBeText()
+
+        clickOptionsModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        // affected cells have fixed text color and default background color
+        TEST_LEGEND_E2E.cells.forEach((cell) =>
+            cy
+                .getBySel('table-body')
+                .contains(cell.value)
+                .should('have.css', 'color', cell.color)
+                .closest('td')
+                .should('have.css', 'background-color', defaultBackgroundColor)
+        )
+
+        // background color legend is applied (single legend)
+        openLegendOptionsModal()
+
+        cy.getBySel('options-modal-content').should('contain', 'Legend style')
+
+        expectLegendDisplayStrategyToBeFixed()
+
+        expectLegendDisplayStyleToBeText()
+
+        cy.getBySel('options-modal-content')
+            .contains('Legend changes background color')
+            .click()
+
+        expectLegendDisplayStyleToBeFill()
+
+        clickOptionsModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        // affected cells have default text color and fixed background color
+        TEST_LEGEND_E2E.cells.forEach((cell) =>
+            cy
+                .getBySel('table-body')
+                .contains(cell.value)
+                .should('have.css', 'color', defaultTextColor)
+                .closest('td')
+                .should('have.css', 'background-color', cell.color)
+        )
+
+        // options can be saved and loaded
+        const AO_NAME = `TEST ${new Date().toLocaleString()}`
+        saveVisualization(AO_NAME)
+        expectAOTitleToContain(AO_NAME)
+        expectTableToBeVisible()
+
+        // affected cells have default text color and fixed background color
+        TEST_LEGEND_E2E.cells.forEach((cell) =>
+            cy
+                .getBySel('table-body')
+                .contains(cell.value)
+                .should('have.css', 'color', defaultTextColor)
+                .closest('td')
+                .should('have.css', 'background-color', cell.color)
+        )
+
+        openLegendOptionsModal()
+
+        expectLegendDisplayStrategyToBeFixed()
+
+        expectLegendDisplayStyleToBeFill()
+
+        cy.getBySel('fixed-legend-set-select-content').contains(
+            TEST_LEGEND_E2E.name
+        )
+
+        clickOptionsModalUpdateButton()
+
+        // saved AO can be deleted
         deleteVisualization()
 
         expectRouteToBeEmpty()
diff --git a/cypress/integration/options.cy.js b/cypress/integration/options.cy.js
index e92fd9dfd..00571c75b 100644
--- a/cypress/integration/options.cy.js
+++ b/cypress/integration/options.cy.js
@@ -14,6 +14,7 @@ import { goToAO } from '../helpers/common.js'
 import {
     selectEnrollmentWithProgramDimensions,
     selectEventWithProgramDimensions,
+    selectTrackedEntityWithTypeAndProgramDimensions,
 } from '../helpers/dimensions.js'
 import { saveVisualization } from '../helpers/fileMenu.js'
 import {
@@ -141,8 +142,8 @@ describe('options', () => {
         const PHONE_NUMBER = '555-1212'
 
         // assert the default dgs space on number but not phone number
-        getTableRows().eq(0).find('td').eq(1).should('contain', PHONE_NUMBER)
-        getTableRows().eq(0).find('td').eq(2).should('contain', '333 333 444')
+        getTableRows().eq(0).find('td').eq(1).should('have.text', PHONE_NUMBER)
+        getTableRows().eq(0).find('td').eq(2).should('have.text', '333 333 444')
 
         // set dgs to comma
         openStyleOptionsModal()
@@ -153,8 +154,8 @@ describe('options', () => {
         cy.contains('Comma').click()
         clickOptionsModalUpdateButton()
 
-        getTableRows().eq(0).find('td').eq(1).should('contain', PHONE_NUMBER)
-        getTableRows().eq(0).find('td').eq(2).should('contain', '333,333,444')
+        getTableRows().eq(0).find('td').eq(1).should('have.text', PHONE_NUMBER)
+        getTableRows().eq(0).find('td').eq(2).should('have.text', '333,333,444')
 
         // set dgs to none
         openStyleOptionsModal()
@@ -165,8 +166,8 @@ describe('options', () => {
         cy.contains('None').click()
         clickOptionsModalUpdateButton()
 
-        getTableRows().eq(0).find('td').eq(1).should('contain', PHONE_NUMBER)
-        getTableRows().eq(0).find('td').eq(2).should('contain', '333333444')
+        getTableRows().eq(0).find('td').eq(1).should('have.text', PHONE_NUMBER)
+        getTableRows().eq(0).find('td').eq(2).should('have.text', '333333444')
 
         // set dgs to space
         openStyleOptionsModal()
@@ -177,8 +178,8 @@ describe('options', () => {
         cy.contains('Space').click()
         clickOptionsModalUpdateButton()
 
-        getTableRows().eq(0).find('td').eq(1).should('contain', PHONE_NUMBER)
-        getTableRows().eq(0).find('td').eq(2).should('contain', '333 333 444')
+        getTableRows().eq(0).find('td').eq(1).should('have.text', PHONE_NUMBER)
+        getTableRows().eq(0).find('td').eq(2).should('have.text', '333 333 444')
     })
 })
 
@@ -244,18 +245,92 @@ describe(['>=40'], 'ou hierarchy', () => {
     })
 })
 
+const testSkipRoundingForEvent = (roundedValue) => {
+    goToStartPage()
+
+    // set up table
+    selectEventWithProgramDimensions({
+        ...E2E_PROGRAM,
+        dimensions: [TEST_DIM_NUMBER],
+    })
+
+    selectRelativePeriod({
+        label: E2E_PROGRAM[DIMENSION_ID_EVENT_DATE],
+        period: TEST_REL_PE_THIS_YEAR,
+    })
+
+    clickMenubarUpdateButton()
+
+    getTableHeaderCells().find(`button[title*="${TEST_DIM_NUMBER}"]`).click()
+
+    expectTableToBeUpdated()
+
+    getTableRows().eq(0).find('td').eq(1).should('have.text', roundedValue)
+
+    openDataOptionsModal()
+
+    cy.getBySel('skip-rounding').click()
+    clickOptionsModalUpdateButton()
+
+    getTableRows().eq(0).find('td').eq(1).should('have.text', 3.123456)
+}
+
+const testSkipRoundingForEnrollment = (roundedValue) => {
+    goToStartPage()
+
+    // set up table
+    selectEnrollmentWithProgramDimensions({
+        ...E2E_PROGRAM,
+        dimensions: [TEST_DIM_NUMBER],
+    })
+
+    selectRelativePeriod({
+        label: E2E_PROGRAM[DIMENSION_ID_ENROLLMENT_DATE],
+        period: TEST_REL_PE_THIS_YEAR,
+    })
+
+    clickMenubarUpdateButton()
+
+    getTableHeaderCells().find(`button[title*="${TEST_DIM_NUMBER}"]`).click()
+
+    expectTableToBeUpdated()
+
+    getTableRows().eq(0).find('td').eq(1).should('have.text', roundedValue)
+
+    openDataOptionsModal()
+
+    cy.getBySel('skip-rounding').click()
+    clickOptionsModalUpdateButton()
+
+    getTableRows().eq(0).find('td').eq(1).should('have.text', 3.123456)
+}
+
 describe('skip rounding', () => {
-    it('sets skip rounding', () => {
+    it(['<41'], 'sets skip rounding for event (below 41)', () => {
+        testSkipRoundingForEvent('3.1')
+    })
+    it(['>=41'], 'sets skip rounding for event (41 and above)', () => {
+        testSkipRoundingForEvent('3.12')
+    })
+    // FIXME: Blocked by backend issue https://dhis2.atlassian.net/browse/DHIS2-17027 (currently unsure if this will be backported though)
+    it.skip(['<41'], 'sets skip rounding for enrollment (below 41)', () => {
+        testSkipRoundingForEnrollment('3.1')
+    })
+    it(['>=41'], 'sets skip rounding for enrollment (41 and above)', () => {
+        testSkipRoundingForEnrollment('3.12')
+    })
+    it(['>=41'], 'sets skip rounding for tracked entity (41 and above)', () => {
         goToStartPage()
 
         // set up table
-        selectEventWithProgramDimensions({
-            ...E2E_PROGRAM,
+        selectTrackedEntityWithTypeAndProgramDimensions({
+            typeName: 'Person',
+            programName: E2E_PROGRAM.programName,
             dimensions: [TEST_DIM_NUMBER],
         })
 
         selectRelativePeriod({
-            label: E2E_PROGRAM[DIMENSION_ID_EVENT_DATE],
+            label: E2E_PROGRAM[DIMENSION_ID_ENROLLMENT_DATE],
             period: TEST_REL_PE_THIS_YEAR,
         })
 
@@ -267,13 +342,13 @@ describe('skip rounding', () => {
 
         expectTableToBeUpdated()
 
-        getTableRows().eq(0).find('td').eq(1).should('contain', 3.7)
+        getTableRows().eq(0).find('td').eq(1).should('have.text', 3.12)
 
         openDataOptionsModal()
 
         cy.getBySel('skip-rounding').click()
         clickOptionsModalUpdateButton()
 
-        getTableRows().eq(0).find('td').eq(1).should('contain', 3.65)
+        getTableRows().eq(0).find('td').eq(1).should('have.text', 3.123456)
     })
 })
diff --git a/cypress/integration/programDimensions.cy.js b/cypress/integration/programDimensions.cy.js
index 11725a6b9..6f3e1dc69 100644
--- a/cypress/integration/programDimensions.cy.js
+++ b/cypress/integration/programDimensions.cy.js
@@ -352,7 +352,7 @@ I.e. Scheduled date works like this:
 
             openInputSidebar()
 
-            cy.getBySel('program-select').click()
+            cy.getBySel('program-dimensions-program-select').click()
 
             cy.contains(E2E_PROGRAM.programName).click()
 
diff --git a/cypress/integration/programStatus.cy.js b/cypress/integration/programStatus.cy.js
new file mode 100644
index 000000000..a5d92d026
--- /dev/null
+++ b/cypress/integration/programStatus.cy.js
@@ -0,0 +1,72 @@
+import {
+    clickAddRemoveProgramDimension,
+    openProgramDimensionsSidebar,
+    selectProgramForTE,
+    selectTrackedEntityWithType,
+} from '../helpers/dimensions.js'
+import {
+    assertChipContainsText,
+    assertTooltipContainsEntries,
+} from '../helpers/layout.js'
+import { clickMenubarUpdateButton } from '../helpers/menubar.js'
+import { goToStartPage } from '../helpers/startScreen.js'
+import {
+    getTableHeaderCells,
+    expectTableToBeVisible,
+    expectTableToMatchRows,
+    getTableRows,
+} from '../helpers/table.js'
+
+describe(['>=41'], 'program status (TE)', () => {
+    const setUpTable = () => {
+        goToStartPage()
+
+        // Select tracked entity type
+        selectTrackedEntityWithType('Person')
+
+        // Select program status from child program
+        openProgramDimensionsSidebar()
+        selectProgramForTE('Child Programme')
+        clickAddRemoveProgramDimension('Program status')
+        clickMenubarUpdateButton()
+
+        expectTableToBeVisible()
+    }
+
+    it('can be filtered by status COMPLETED', () => {
+        setUpTable()
+
+        clickMenubarUpdateButton()
+
+        // expect a table with at least 10 rows a table header and correct layout chip
+        expectTableToBeVisible()
+        getTableRows().its('length').should('be.gte', 10)
+        getTableHeaderCells()
+            .contains('Program status, Child Programme')
+            .should('be.visible')
+        assertChipContainsText('Program status', 'all', 'Child Programme')
+
+        // Add filter 'Completed'
+
+        cy.getBySel('columns-axis').contains('Program status').click()
+        cy.getBySel('program-status-checkbox')
+            .contains('Completed')
+            .click()
+            .find('[type="checkbox"]')
+            .should('be.checked')
+        cy.getBySelLike('programStatus-modal-action-confirm')
+            .contains('Update')
+            .click()
+
+        // expect a table with fewer rows and the layout chip to reflect the added filter
+        expectTableToBeVisible()
+        expectTableToMatchRows([
+            'Completed',
+            'Completed',
+            'Completed',
+            'Completed',
+        ])
+        assertChipContainsText('Program status', 1, 'Child Programme')
+        assertTooltipContainsEntries(['Completed'])
+    })
+})
diff --git a/cypress/integration/repeatedEvents.cy.js b/cypress/integration/repeatedEvents.cy.js
index cda6082a5..02ba6cf46 100644
--- a/cypress/integration/repeatedEvents.cy.js
+++ b/cypress/integration/repeatedEvents.cy.js
@@ -5,6 +5,8 @@ import {
 import { E2E_PROGRAM, TEST_REL_PE_LAST_YEAR } from '../data/index.js'
 import { goToAO } from '../helpers/common.js'
 import {
+    clickAddRemoveProgramDataDimension,
+    clickAddRemoveProgramDimension,
     openDimension,
     openInputSidebar,
     openProgramDimensionsSidebar,
@@ -12,9 +14,18 @@ import {
     selectEnrollmentWithProgramDimensions,
     selectEventWithProgram,
     selectEventWithProgramDimensions,
+    selectProgramForTE,
+    selectTrackedEntityWithType,
 } from '../helpers/dimensions.js'
 import { assertChipContainsText } from '../helpers/layout.js'
 import { clickMenubarUpdateButton } from '../helpers/menubar.js'
+import {
+    clickOrgUnitDimensionModalUpdateButton,
+    expectOrgUnitDimensionModalToBeVisible,
+    expectOrgUnitDimensionToNotBeLoading,
+    openOrgUnitTreeItem,
+    selectOrgUnitTreeItem,
+} from '../helpers/orgUnit.js'
 import { selectRelativePeriod } from '../helpers/period.js'
 import { goToStartPage } from '../helpers/startScreen.js'
 import {
@@ -109,11 +120,11 @@ describe('repeated events', () => {
         })
         expectHeaderToContainExact(
             0,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent -1)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -1)'
         )
         expectHeaderToContainExact(
             1,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent)'
         )
 
         // repetition 0/2 can be set successfully
@@ -124,11 +135,11 @@ describe('repeated events', () => {
         })
         expectHeaderToContainExact(
             0,
-            'E2E - Percentage - Stage 1 - Repeatable (oldest)'
+            'E2E - Percentage, Stage 1 - Repeatable (oldest)'
         )
         expectHeaderToContainExact(
             1,
-            'E2E - Percentage - Stage 1 - Repeatable (oldest +1)'
+            'E2E - Percentage, Stage 1 - Repeatable (oldest +1)'
         )
 
         // repetition 2/2 can be set successfully
@@ -139,19 +150,19 @@ describe('repeated events', () => {
         })
         expectHeaderToContainExact(
             0,
-            'E2E - Percentage - Stage 1 - Repeatable (oldest)'
+            'E2E - Percentage, Stage 1 - Repeatable (oldest)'
         )
         expectHeaderToContainExact(
             1,
-            'E2E - Percentage - Stage 1 - Repeatable (oldest +1)'
+            'E2E - Percentage, Stage 1 - Repeatable (oldest +1)'
         )
         expectHeaderToContainExact(
             2,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent -1)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -1)'
         )
         expectHeaderToContainExact(
             3,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent)'
         )
 
         // switch back to event, check that repetition is cleared
@@ -173,6 +184,105 @@ describe('repeated events', () => {
         // no repetition in header
         expectHeaderToContainExact(0, dimensionName)
     })
+    it(['>=41'], 'can use repetition for TE', () => {
+        // switch to Tracked entity and select a type
+        selectTrackedEntityWithType('Person')
+
+        openProgramDimensionsSidebar()
+
+        selectProgramForTE(E2E_PROGRAM.programName)
+
+        const dimensionName = 'E2E - Percentage'
+
+        clickAddRemoveProgramDataDimension(dimensionName)
+
+        // remove reg ou
+        cy.getBySel('columns-axis')
+            .findBySel('dimension-menu-button-ou')
+            .click()
+        cy.contains('Remove').click()
+
+        // add program ou
+        clickAddRemoveProgramDimension('Organisation unit')
+
+        // move program ou to filter
+        cy.getBySel('columns-axis')
+            .findBySel('dimension-menu-button-J1QQtmzqhJz.ou')
+            .click()
+        cy.contains('Move to Filter').click()
+
+        // filter program ou to Badjia
+        cy.getBySel('filters-axis').contains('Organisation unit').click()
+        expectOrgUnitDimensionModalToBeVisible()
+        expectOrgUnitDimensionToNotBeLoading()
+        openOrgUnitTreeItem('Bo')
+        openOrgUnitTreeItem('Badjia')
+        selectOrgUnitTreeItem('Njandama MCHP')
+        clickOrgUnitDimensionModalUpdateButton()
+
+        expectTableToBeVisible()
+
+        assertChipContainsText(dimensionName, 'all')
+
+        // initially only has 1 column and 1 row
+        getTableHeaderCells().its('length').should('equal', 1)
+        getTableHeaderCells().eq(0).containsExact(dimensionName)
+        getTableDataCells().eq(0).invoke('text').should('eq', '46')
+        expectRepetitionToBe({ dimensionName, recent: 1, oldest: 0 })
+
+        // repetition 2/0 can be set successfully
+        setRepetition({ dimensionName, recent: 2, oldest: 0 })
+        let result = ['45', '46']
+        result.forEach((value, index) => {
+            getTableDataCells().eq(index).invoke('text').should('eq', value)
+        })
+        expectHeaderToContainExact(
+            0,
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -1)'
+        )
+        expectHeaderToContainExact(
+            1,
+            'E2E - Percentage, Stage 1 - Repeatable (most recent)'
+        )
+
+        // repetition 0/2 can be set successfully
+        setRepetition({ dimensionName, recent: 0, oldest: 2 })
+        result = ['45', '46']
+        result.forEach((value, index) => {
+            getTableDataCells().eq(index).contains(value)
+        })
+        expectHeaderToContainExact(
+            0,
+            'E2E - Percentage, Stage 1 - Repeatable (oldest)'
+        )
+        expectHeaderToContainExact(
+            1,
+            'E2E - Percentage, Stage 1 - Repeatable (oldest +1)'
+        )
+
+        // repetition 2/2 can be set successfully
+        setRepetition({ dimensionName, recent: 2, oldest: 2 })
+        result = ['45', '46', '45', '46']
+        result.forEach((value, index) => {
+            getTableDataCells().eq(index).invoke('text').should('eq', value)
+        })
+        expectHeaderToContainExact(
+            0,
+            'E2E - Percentage, Stage 1 - Repeatable (oldest)'
+        )
+        expectHeaderToContainExact(
+            1,
+            'E2E - Percentage, Stage 1 - Repeatable (oldest +1)'
+        )
+        expectHeaderToContainExact(
+            2,
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -1)'
+        )
+        expectHeaderToContainExact(
+            3,
+            'E2E - Percentage, Stage 1 - Repeatable (most recent)'
+        )
+    })
     it('repetition out of bounds returns as empty value', () => {
         const dimensionName = 'E2E - Percentage'
         setUpTable({ enrollment: E2E_PROGRAM, dimensionName })
@@ -185,15 +295,15 @@ describe('repeated events', () => {
         })
         expectHeaderToContainExact(
             0,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent -5)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -5)'
         )
         expectHeaderToContainExact(
             2,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent -3)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent -3)'
         )
         expectHeaderToContainExact(
             5,
-            'E2E - Percentage - Stage 1 - Repeatable (most recent)'
+            'E2E - Percentage, Stage 1 - Repeatable (most recent)'
         )
     })
     it('repetition is disabled for non repetable stages', () => {
diff --git a/cypress/integration/save.cy.js b/cypress/integration/save.cy.js
index d60f3e57e..3a07970bf 100644
--- a/cypress/integration/save.cy.js
+++ b/cypress/integration/save.cy.js
@@ -1,9 +1,11 @@
+import { AXIS_ID_COLUMNS } from '@dhis2/analytics'
 import {
     DIMENSION_ID_ENROLLMENT_DATE,
     DIMENSION_ID_EVENT_DATE,
 } from '../../src/modules/dimensionConstants.js'
 import {
     E2E_PROGRAM,
+    TEST_DIM_NUMBER,
     TEST_FIX_PE_DEC_LAST_YEAR,
     TEST_REL_PE_LAST_YEAR,
 } from '../data/index.js'
@@ -11,14 +13,17 @@ import { goToAO } from '../helpers/common.js'
 import {
     openProgramDimensionsSidebar,
     selectEventWithProgram,
+    selectTrackedEntityWithTypeAndProgramDimensions,
 } from '../helpers/dimensions.js'
 import {
     deleteVisualization,
+    openAOByName,
     renameVisualization,
     resaveVisualization,
     saveVisualization,
     saveVisualizationAs,
 } from '../helpers/fileMenu.js'
+import { expectAxisToHaveDimension } from '../helpers/layout.js'
 import {
     clickMenubarUpdateButton,
     clickMenubarInterpretationsButton,
@@ -112,8 +117,8 @@ describe('rename', () => {
 })
 
 describe('save', () => {
-    it('new AO with name saves correctly', () => {
-        const AO_NAME = `TEST ${new Date().toLocaleString()}`
+    it('new AO with name saves correctly (event)', () => {
+        const AO_NAME = `TEST event ${new Date().toLocaleString()}`
         const UPDATED_AO_NAME = AO_NAME + ' 2'
         setupTable()
 
@@ -122,6 +127,11 @@ describe('save', () => {
         expectAOTitleToContain(AO_NAME)
         expectTableToBeVisible()
 
+        // open AO by name
+        goToStartPage()
+        openAOByName(AO_NAME)
+        expectTableToBeVisible()
+
         // save as with name change
         saveVisualizationAs(UPDATED_AO_NAME)
         expectAOTitleToContain(UPDATED_AO_NAME)
@@ -134,7 +144,49 @@ describe('save', () => {
 
         deleteVisualization()
     })
+    it(['>=41'], 'new AO with name saves correctly (TE)', () => {
+        const AO_NAME = `TEST TE ${new Date().toLocaleString()}`
+        const UPDATED_AO_NAME = AO_NAME + ' 2'
+
+        // set up a simple TE line list
+        goToStartPage()
+        selectTrackedEntityWithTypeAndProgramDimensions({
+            typeName: 'Person',
+            programName: event.programName,
+            dimensions: [TEST_DIM_NUMBER],
+        })
+        clickMenubarUpdateButton()
+        expectTableToBeVisible()
+
+        // save with a name
+        saveVisualization(AO_NAME)
+        expectAOTitleToContain(AO_NAME)
+        expectTableToBeVisible()
+
+        // open AO by name
+        goToStartPage()
+        openAOByName(AO_NAME)
+        expectTableToBeVisible()
 
+        // expect axis to contain dimension with properly prefixed id
+        expectAxisToHaveDimension(
+            AXIS_ID_COLUMNS,
+            'J1QQtmzqhJz.jfuXZB3A1ko.Vcu7eF3ndYW'
+        )
+
+        // save as with name change
+        saveVisualizationAs(UPDATED_AO_NAME)
+        expectAOTitleToContain(UPDATED_AO_NAME)
+        expectTableToBeVisible()
+
+        // save as without name change
+        saveVisualizationAs()
+        expectAOTitleToContain(UPDATED_AO_NAME + ' (copy)')
+        expectTableToBeVisible()
+
+        // delete AO to clean up
+        deleteVisualization()
+    })
     it('new AO without name saves correctly', () => {
         cy.clock(cy.clock(Date.UTC(2022, 11, 29), ['Date'])) // month is 0-indexed, 11 = December
         const EXPECTED_AO_NAME_PART_1 = 'Untitled Line list visualization'
diff --git a/cypress/integration/timeDimensions.cy.js b/cypress/integration/timeDimensions.cy.js
index 55a0d225d..80de48644 100644
--- a/cypress/integration/timeDimensions.cy.js
+++ b/cypress/integration/timeDimensions.cy.js
@@ -33,8 +33,9 @@ const assertTimeDimension = (dimension) => {
             selectFixedPeriod({
                 label,
                 period: {
+                    type: 'Monthly',
                     year: '2023',
-                    name: '2023',
+                    name: 'January 2023',
                 },
             })
         } else {
@@ -69,7 +70,7 @@ describe(['>37', '<39'], 'time dimensions', () => {
         { id: DIMENSION_ID_EVENT_DATE, rowsLength: 7 },
         { id: DIMENSION_ID_ENROLLMENT_DATE, rowsLength: 12 },
         { id: DIMENSION_ID_INCIDENT_DATE, rowsLength: 12 },
-        { id: DIMENSION_ID_LAST_UPDATED, rowsLength: 11 },
+        { id: DIMENSION_ID_LAST_UPDATED, rowsLength: 10 },
     ]
 
     timeDimensions.forEach((dimension) => {
@@ -87,7 +88,7 @@ describe(['>=39'], 'time dimensions', () => {
         { id: DIMENSION_ID_EVENT_DATE, rowsLength: 7 },
         { id: DIMENSION_ID_ENROLLMENT_DATE, rowsLength: 13 },
         { id: DIMENSION_ID_INCIDENT_DATE, rowsLength: 13 },
-        { id: DIMENSION_ID_LAST_UPDATED, rowsLength: 12 },
+        { id: DIMENSION_ID_LAST_UPDATED, rowsLength: 11 },
         { id: DIMENSION_ID_SCHEDULED_DATE, rowsLength: 7 },
     ]
 
diff --git a/i18n/en.pot b/i18n/en.pot
index ffe09471b..2c9821f0b 100644
--- a/i18n/en.pot
+++ b/i18n/en.pot
@@ -5,8 +5,8 @@ msgstr ""
 "Content-Type: text/plain; charset=utf-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=2; plural=(n != 1)\n"
-"POT-Creation-Date: 2024-01-12T10:52:11.438Z\n"
-"PO-Revision-Date: 2024-01-12T10:52:11.438Z\n"
+"POT-Creation-Date: 2024-02-13T14:56:50.029Z\n"
+"PO-Revision-Date: 2024-02-13T14:56:50.030Z\n"
 
 msgid "Add to {{axisName}}"
 msgstr "Add to {{axisName}}"
@@ -176,18 +176,24 @@ msgstr[1] "And {{count}} others..."
 msgid "None selected"
 msgstr "None selected"
 
-msgid "Showing all values for this dimension"
-msgstr "Showing all values for this dimension"
-
 msgid "Program stage: {{- stageName}}"
 msgstr "Program stage: {{- stageName}}"
 
+msgid "Program: {{- programName}}"
+msgstr "Program: {{- programName}}"
+
+msgid "Showing all values for this dimension"
+msgstr "Showing all values for this dimension"
+
 msgid "No dimensions found for '{{- searchTerm}}'"
 msgstr "No dimensions found for '{{- searchTerm}}'"
 
 msgid "No dimensions found in the {{- programName}} program"
 msgstr "No dimensions found in the {{- programName}} program"
 
+msgid " {{- trackedEntityType}} has no dimensions"
+msgstr " {{- trackedEntityType}} has no dimensions"
+
 msgid "No dimensions found"
 msgstr "No dimensions found"
 
@@ -207,15 +213,8 @@ msgstr "Event"
 msgid "Enrollment"
 msgstr "Enrollment"
 
-msgid "Could not load programs"
-msgstr "Could not load programs"
-
-msgid ""
-"The programs couldn't be retrieved. Try again or contact your system "
-"administrator."
-msgstr ""
-"The programs couldn't be retrieved. Try again or contact your system "
-"administrator."
+msgid "Tracked entity"
+msgstr "Tracked entity"
 
 msgid "See individual event data from a Tracker program stage or event program."
 msgstr "See individual event data from a Tracker program stage or event program."
@@ -223,6 +222,9 @@ msgstr "See individual event data from a Tracker program stage or event program.
 msgid "See data from multiple program stages in a Tracker program."
 msgstr "See data from multiple program stages in a Tracker program."
 
+msgid "See individual tracked entities from one or more Tracker programs."
+msgstr "See individual tracked entities from one or more Tracker programs."
+
 msgid "Global dimensions"
 msgstr "Global dimensions"
 
@@ -265,6 +267,19 @@ msgstr "Category option group set"
 msgid "Choose an input to get started adding program dimensions."
 msgstr "Choose an input to get started adding program dimensions."
 
+msgid "Program"
+msgstr "Program"
+
+msgid "Could not load programs"
+msgstr "Could not load programs"
+
+msgid ""
+"The programs couldn't be retrieved. Try again or contact your system "
+"administrator."
+msgstr ""
+"The programs couldn't be retrieved. Try again or contact your system "
+"administrator."
+
 msgid "Choose a program"
 msgstr "Choose a program"
 
@@ -280,6 +295,34 @@ msgstr "All"
 msgid "No stages found"
 msgstr "No stages found"
 
+msgid "Could not load types"
+msgstr "Could not load types"
+
+msgid ""
+"The types couldn't be retrieved. Try again or contact your system "
+"administrator."
+msgstr ""
+"The types couldn't be retrieved. Try again or contact your system "
+"administrator."
+
+msgid "Choose a type"
+msgstr "Choose a type"
+
+msgid "No types found"
+msgstr "No types found"
+
+msgid "{{- itemName}} dimensions"
+msgstr "{{- itemName}} dimensions"
+
+msgid "Filter by program usage"
+msgstr "Filter by program usage"
+
+msgid "Clear"
+msgstr "Clear"
+
+msgid "Search dimensions"
+msgstr "Search dimensions"
+
 msgid "Your dimensions"
 msgstr "Your dimensions"
 
@@ -588,6 +631,12 @@ msgstr ""
 "The visualization you are trying to view could not be found, the ID could "
 "be incorrect or it could have been deleted."
 
+msgid "No tracked entity type selected"
+msgstr "No tracked entity type selected"
+
+msgid "Choose a type from the Input sidebar."
+msgstr "Choose a type from the Input sidebar."
+
 msgid "No program selected"
 msgstr "No program selected"
 
@@ -642,6 +691,9 @@ msgstr ""
 msgid "There's a syntax problem with the analytics request."
 msgstr "There's a syntax problem with the analytics request."
 
+msgid "Registration date"
+msgstr "Registration date"
+
 msgid "Last updated on"
 msgstr "Last updated on"
 
@@ -660,6 +712,12 @@ msgstr "User sub-units"
 msgid "User sub-x2-units"
 msgstr "User sub-x2-units"
 
+msgid "Registration org. unit"
+msgstr "Registration org. unit"
+
+msgid "Organisation unit"
+msgstr "Organisation unit"
+
 msgid "Table title"
 msgstr "Table title"
 
@@ -687,9 +745,6 @@ msgstr "Limit minimum/maximum values"
 msgid "Style"
 msgstr "Style"
 
-msgid "Organisation unit"
-msgstr "Organisation unit"
-
 msgid "Event status"
 msgstr "Event status"
 
diff --git a/package.json b/package.json
index 262f21ca8..547dbc50a 100644
--- a/package.json
+++ b/package.json
@@ -38,9 +38,9 @@
         "typescript": "^4.8.4"
     },
     "dependencies": {
-        "@dhis2/analytics": "^26.3.0",
+        "@dhis2/analytics": "^26.6.0",
         "@dhis2/app-runtime": "^3.4.4",
-        "@dhis2/ui": "^8.14.5",
+        "@dhis2/ui": "^9.4.2",
         "@dnd-kit/core": "^5.0.3",
         "@dnd-kit/sortable": "^6.0.1",
         "@dnd-kit/utilities": "^3.2.0",
@@ -61,7 +61,7 @@
         "styled-jsx": "^4.0.1"
     },
     "resolutions": {
-        "@dhis2/ui": "^8.3.1",
+        "@dhis2/ui": "^9.4.2",
         "i18next": "^20.5.0"
     }
 }
diff --git a/src/actions/current.js b/src/actions/current.js
index 743a5df47..cb0954793 100644
--- a/src/actions/current.js
+++ b/src/actions/current.js
@@ -1,6 +1,7 @@
 import { genericClientError } from '../modules/error.js'
 import {
     layoutHasProgramId,
+    layoutHasTrackedEntityTypeId,
     validateLayout,
 } from '../modules/layoutValidation.js'
 import {
@@ -51,7 +52,11 @@ export const tSetCurrentFromUi =
         }
 
         if (!validateOnly) {
-            if (layoutHasProgramId(currentFromUi)) {
+            // proceed if the layout either has a program id or a tracked entity type id
+            if (
+                layoutHasProgramId(currentFromUi) ||
+                layoutHasTrackedEntityTypeId(currentFromUi)
+            ) {
                 dispatch(acSetCurrent(currentFromUi))
             } else {
                 dispatch(acClearCurrent())
diff --git a/src/actions/ui.js b/src/actions/ui.js
index 26db5dc48..dc9024643 100644
--- a/src/actions/ui.js
+++ b/src/actions/ui.js
@@ -1,3 +1,4 @@
+import { DIMENSION_ID_ORGUNIT } from '@dhis2/analytics'
 import {
     DIMENSION_TYPES_PROGRAM,
     DIMENSION_IDS_TIME,
@@ -5,14 +6,20 @@ import {
     DIMENSION_ID_PROGRAM_STATUS,
     DIMENSION_ID_SCHEDULED_DATE,
     DIMENSION_ID_LAST_UPDATED,
+    DIMENSION_ID_CREATED,
 } from '../modules/dimensionConstants.js'
+import { extractDimensionIdParts } from '../modules/dimensionId.js'
 import {
     getDefaultTimeDimensionsMetadata,
     getDynamicTimeDimensionsMetadata,
     getProgramAsMetadata,
+    getDefaultOuMetadata,
 } from '../modules/metadata.js'
 import { PROGRAM_TYPE_WITH_REGISTRATION } from '../modules/programTypes.js'
-import { OUTPUT_TYPE_EVENT } from '../modules/visualization.js'
+import {
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../modules/visualization.js'
 import { sGetMetadataById } from '../reducers/metadata.js'
 import {
     ADD_UI_LAYOUT_DIMENSIONS,
@@ -44,6 +51,8 @@ import {
     TOGGLE_UI_SIDEBAR_HIDDEN,
     TOGGLE_UI_LAYOUT_PANEL_HIDDEN,
     SET_UI_ACCESSORY_PANEL_ACTIVE_TAB,
+    UPDATE_UI_ENTITY_TYPE_ID,
+    CLEAR_UI_ENTITY_TYPE,
 } from '../reducers/ui.js'
 
 export const acSetUiDraggingId = (value) => ({
@@ -67,6 +76,11 @@ export const acClearUiStageId = (metadata) => ({
     metadata,
 })
 
+export const acClearUiEntityType = () => ({
+    type: CLEAR_UI_ENTITY_TYPE,
+    metadata: getDefaultTimeDimensionsMetadata(),
+})
+
 export const acUpdateUiProgramId = (value, metadata) => ({
     type: UPDATE_UI_PROGRAM_ID,
     value,
@@ -79,21 +93,31 @@ export const acUpdateUiProgramStageId = (value, metadata) => ({
     metadata,
 })
 
+export const acUpdateUiEntityTypeId = (value, metadata) => ({
+    type: UPDATE_UI_ENTITY_TYPE_ID,
+    value,
+    metadata,
+})
+
 const tClearUiProgramRelatedDimensions = () => (dispatch, getState) => {
     const { ui, metadata } = getState()
 
     const idsToRemove = ui.layout.columns
         .concat(ui.layout.filters)
-        .filter((dimensionId) => {
-            const dimension = metadata[dimensionId]
+        .filter((id) => {
+            const dimension = metadata[id]
+            const { dimensionId } = extractDimensionIdParts(id)
             const isProgramDataDimension = DIMENSION_TYPES_PROGRAM.has(
                 dimension.dimensionType
             )
             const isProgramDimension =
                 dimensionId === DIMENSION_ID_PROGRAM_STATUS ||
                 dimensionId === DIMENSION_ID_EVENT_STATUS ||
-                (DIMENSION_IDS_TIME.has(dimension.id) &&
-                    dimensionId !== DIMENSION_ID_LAST_UPDATED)
+                (dimensionId === DIMENSION_ID_ORGUNIT &&
+                    id !== DIMENSION_ID_ORGUNIT) ||
+                (DIMENSION_IDS_TIME.has(dimensionId) &&
+                    dimensionId !== DIMENSION_ID_LAST_UPDATED) ||
+                dimensionId === DIMENSION_ID_CREATED
             return isProgramDataDimension || isProgramDimension
         })
 
@@ -123,27 +147,50 @@ export const tClearUiProgramStageDimensions =
     }
 
 export const tSetUiInput = (value) => (dispatch) => {
+    dispatch(acClearUiEntityType())
     dispatch(acClearUiProgram())
     dispatch(tClearUiProgramRelatedDimensions())
     dispatch(acClearUiRepetition())
-    dispatch(acSetUiInput(value, getDefaultTimeDimensionsMetadata()))
+    dispatch(
+        acSetUiInput(value, {
+            ...getDefaultTimeDimensionsMetadata(),
+            ...getDefaultOuMetadata(value.type),
+        })
+    )
 }
 
 export const tSetUiProgram =
     ({ program, stage }) =>
-    (dispatch) => {
+    (dispatch, getState) => {
+        const state = getState()
         dispatch(acClearUiProgram())
-        dispatch(tClearUiProgramRelatedDimensions())
+        const inputType = sGetUiInputType(state)
+        if (inputType !== OUTPUT_TYPE_TRACKED_ENTITY) {
+            dispatch(tClearUiProgramRelatedDimensions())
+        }
         program &&
             dispatch(
                 acUpdateUiProgramId(program.id, {
                     ...getProgramAsMetadata(program),
-                    ...getDynamicTimeDimensionsMetadata(program, stage),
+                    ...getDynamicTimeDimensionsMetadata(
+                        program,
+                        stage,
+                        inputType
+                    ),
                 })
             )
         stage && dispatch(acUpdateUiProgramStageId(stage.id))
     }
 
+export const tSetUiEntityType =
+    ({ type }) =>
+    (dispatch) => {
+        dispatch(acClearUiProgram())
+        dispatch(tClearUiProgramRelatedDimensions())
+        dispatch(acClearUiEntityType())
+        dispatch(acUpdateUiEntityTypeId(type.id, { [type.id]: type }))
+    }
+
 export const tClearUiStage = () => (dispatch, getState) => {
     const state = getState()
     const program = sGetMetadataById(state, sGetUiProgramId(state))
diff --git a/src/actions/visualization.js b/src/actions/visualization.js
index 84852af95..45130f693 100644
--- a/src/actions/visualization.js
+++ b/src/actions/visualization.js
@@ -1,9 +1,9 @@
 import { getUiDimensionType } from '../modules/dimensionConstants.js'
+import { formatDimensionId } from '../modules/dimensionId.js'
 import {
     getDynamicTimeDimensionsMetadata,
     getProgramAsMetadata,
 } from '../modules/metadata.js'
-import { formatDimensionId } from '../modules/utils.js'
 import { getDimensionMetadataFromVisualization } from '../modules/visualization.js'
 import {
     SET_VISUALIZATION,
@@ -11,7 +11,7 @@ import {
 } from '../reducers/visualization.js'
 
 export const acSetVisualization = (value) => {
-    const { program, programStage } = value
+    const { outputType, program, programStage } = value
     const timeDimensions = getDynamicTimeDimensionsMetadata(
         program,
         programStage
@@ -28,10 +28,12 @@ export const acSetVisualization = (value) => {
             return md
         }
 
-        const prefixedId = formatDimensionId(
-            dimension.dimension,
-            dimension.programStage?.id
-        )
+        const prefixedId = formatDimensionId({
+            dimensionId: dimension.dimension,
+            programStageId: dimension.programStage?.id,
+            programId: dimension.program?.id,
+            outputType,
+        })
 
         md.push({
             [prefixedId]: {
diff --git a/src/api/legendSets.js b/src/api/legendSets.js
index 8e46fac5d..78dcf31cd 100644
--- a/src/api/legendSets.js
+++ b/src/api/legendSets.js
@@ -3,7 +3,7 @@ import {
     DIMENSION_TYPE_PROGRAM_ATTRIBUTE,
     DIMENSION_TYPE_PROGRAM_INDICATOR,
 } from '@dhis2/analytics'
-import { extractDimensionIdParts } from '../modules/utils.js'
+import { extractDimensionIdParts } from '../modules/dimensionId.js'
 
 const dataElementsQuery = {
     resource: 'dataElements',
diff --git a/src/components/App.js b/src/components/App.js
index ade64bd92..07e237d5c 100644
--- a/src/components/App.js
+++ b/src/components/App.js
@@ -1,4 +1,11 @@
-import { useCachedDataQuery, convertOuLevelsToUids } from '@dhis2/analytics'
+import {
+    useCachedDataQuery,
+    convertOuLevelsToUids,
+    USER_ORG_UNIT,
+    USER_ORG_UNIT_CHILDREN,
+    USER_ORG_UNIT_GRANDCHILDREN,
+    DIMENSION_ID_ORGUNIT,
+} from '@dhis2/analytics'
 import { useDataEngine, useDataMutation } from '@dhis2/app-runtime'
 import { CssVariables } from '@dhis2/ui'
 import cx from 'classnames'
@@ -17,10 +24,16 @@ import {
     acSetUiOpenDimensionModal,
     acAddParentGraphMap,
     acSetShowExpandedLayoutPanel,
+    acSetUiAccessoryPanelActiveTab,
 } from '../actions/ui.js'
 import { acSetVisualization } from '../actions/visualization.js'
 import { parseCondition, OPERATOR_IN } from '../modules/conditions.js'
 import { EVENT_TYPE } from '../modules/dataStatistics.js'
+import {
+    DIMENSION_ID_EVENT_STATUS,
+    DIMENSION_ID_PROGRAM_STATUS,
+} from '../modules/dimensionConstants.js'
+import { formatDimensionId } from '../modules/dimensionId.js'
 import {
     analyticsGenerationError,
     analyticsRequestError,
@@ -33,13 +46,19 @@ import {
     visualizationNotFoundError,
 } from '../modules/error.js'
 import history from '../modules/history.js'
+import {
+    getDefaultOuMetadata,
+    getDynamicTimeDimensionsMetadata,
+} from '../modules/metadata.js'
+import { getParentGraphMapFromVisualization } from '../modules/parentGraphMap.js'
+import { getProgramDimensions } from '../modules/programDimensions.js'
 import { SYSTEM_SETTINGS_DIGIT_GROUP_SEPARATOR } from '../modules/systemSettings.js'
-import { getParentGraphMapFromVisualization } from '../modules/ui.js'
 import {
     DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY,
     USER_SETTINGS_DISPLAY_PROPERTY,
 } from '../modules/userSettings.js'
 import {
+    OUTPUT_TYPE_TRACKED_ENTITY,
     getDimensionMetadataFields,
     transformVisualization,
 } from '../modules/visualization.js'
@@ -63,6 +82,9 @@ import { Toolbar } from './Toolbar/Toolbar.js'
 import StartScreen from './Visualization/StartScreen.js'
 import { Visualization } from './Visualization/Visualization.js'
 
+const dimensionFields = () =>
+    'dimension,dimensionType,filter,program[id],programStage[id],optionSet[id],valueType,legendSet[id],repetition,items[dimensionItem~rename(id)]'
+
 const visualizationQuery = {
     eventVisualization: {
         resource: 'eventVisualizations',
@@ -71,16 +93,18 @@ const visualizationQuery = {
         params: ({ nameProp }) => ({
             fields: [
                 '*',
-                'columns[dimension,dimensionType,filter,programStage[id],optionSet[id],valueType,legendSet[id],repetition,items[dimensionItem~rename(id)]]',
-                'rows[dimension,dimensionType,filter,programStage[id],optionSet[id],valueType,legendSet[id],repetition,items[dimensionItem~rename(id)]]',
-                'filters[dimension,dimensionType,filter,programStage[id],optionSet[id],valueType,legendSet[id],repetition,items[dimensionItem~rename(id)]]',
+                `columns[${dimensionFields}]`,
+                `rows[${dimensionFields}]`,
+                `filters[${dimensionFields}]`,
                 `program[id,programType,${nameProp}~rename(name),displayEnrollmentDateLabel,displayIncidentDateLabel,displayIncidentDate,programStages[id,displayName~rename(name),repeatable]]`,
                 'programStage[id,displayName~rename(name),displayExecutionDateLabel,displayDueDateLabel,hideDueDate,repeatable]',
+                `programDimensions[id,${nameProp}~rename(name),enrollmentDateLabel,incidentDateLabel,programType,displayIncidentDate,displayEnrollmentDateLabel,displayIncidentDateLabel,programStages[id,${nameProp}~rename(name),repeatable,hideDueDate,displayExecutionDateLabel,displayDueDateLabel]]`,
                 'access',
                 'href',
                 ...getDimensionMetadataFields(),
                 'dataElementDimensions[legendSet[id,name],dataElement[id,name]]',
                 'legend[set[id,displayName],strategy,style,showKey]',
+                'trackedEntityType[id,displayName~rename(name)]',
                 '!interpretations',
                 '!userGroupAccesses',
                 '!publicAccess',
@@ -266,8 +290,17 @@ const App = () => {
         dispatch(acSetUiOpenDimensionModal(dimensionId))
 
     const onResponsesReceived = (response) => {
-        const itemsMetadata = Object.entries(response.metaData.items).reduce(
-            (obj, [id, item]) => {
+        const itemsMetadata = Object.entries(response.metaData.items)
+            .filter(
+                ([item]) =>
+                    ![
+                        USER_ORG_UNIT,
+                        USER_ORG_UNIT_CHILDREN,
+                        USER_ORG_UNIT_GRANDCHILDREN,
+                        DIMENSION_ID_ORGUNIT,
+                    ].includes(item)
+            )
+            .reduce((obj, [id, item]) => {
                 obj[id] = {
                     id,
                     name: item.name || item.displayName,
@@ -277,9 +310,7 @@ const App = () => {
                 }
 
                 return obj
-            },
-            {}
-        )
+            }, {})
 
         dispatch(acAddMetadata(itemsMetadata))
         dispatch(acSetVisualizationLoading(false))
@@ -347,8 +378,90 @@ const App = () => {
                 }
             }
         }
+        if (Object.keys(optionSetsMetadata).length) {
+            dispatch(acAddMetadata(optionSetsMetadata))
+        }
+    }
 
-        dispatch(acAddMetadata(optionSetsMetadata))
+    const addTrackedEntityTypeMetadata = (visualization) => {
+        const { id, name } = visualization.trackedEntityType || {}
+
+        if (id && name) {
+            dispatch(acAddMetadata({ [id]: { id, name } }))
+        }
+    }
+    const addFixedDimensionsMetadata = (visualization) => {
+        const fixedDimensionsMetadata = {}
+
+        const dimensions = [
+            ...(visualization.columns || []),
+            ...(visualization.rows || []),
+            ...(visualization.filters || []),
+        ]
+
+        for (const dimension of dimensions.filter(
+            (d) =>
+                [
+                    DIMENSION_ID_ORGUNIT,
+                    DIMENSION_ID_EVENT_STATUS,
+                    DIMENSION_ID_PROGRAM_STATUS,
+                ].includes(d.dimension) && d.program?.id
+        )) {
+            const dimensionId = formatDimensionId({
+                dimensionId: dimension.dimension,
+                programId: dimension.program.id,
+                outputType: visualization.outputType,
+            })
+            const metadata = getProgramDimensions(dimension.program.id)[
+                dimensionId
+            ]
+
+            if (metadata) {
+                fixedDimensionsMetadata[dimensionId] = metadata
+            }
+        }
+        if (
+            visualization.outputType === OUTPUT_TYPE_TRACKED_ENTITY &&
+            dimensions.some((d) => d.dimension === DIMENSION_ID_ORGUNIT)
+        ) {
+            fixedDimensionsMetadata[DIMENSION_ID_ORGUNIT] =
+                getDefaultOuMetadata(visualization.outputType)[
+                    DIMENSION_ID_ORGUNIT
+                ]
+        }
+        if (Object.keys(fixedDimensionsMetadata).length) {
+            dispatch(acAddMetadata(fixedDimensionsMetadata))
+        }
+    }
+
+    const addProgramDimensionsMetadata = (visualization) => {
+        const programDimensionsMetadata = {}
+
+        visualization.programDimensions.forEach((program) => {
+            programDimensionsMetadata[program.id] = program
+
+            const timeDimensions = getDynamicTimeDimensionsMetadata(program)
+            Object.keys(timeDimensions).forEach((timeDimensionId) => {
+                const formattedId = formatDimensionId({
+                    dimensionId: timeDimensionId,
+                    programId: program.id,
+                    outputType: visualization.outputType,
+                })
+                programDimensionsMetadata[formattedId] = {
+                    ...timeDimensions[timeDimensionId],
+                    id: formattedId,
+                }
+            })
+
+            if (program.programStages) {
+                program.programStages.forEach((stage) => {
+                    programDimensionsMetadata[stage.id] = stage
+                })
+            }
+        })
+        if (Object.keys(programDimensionsMetadata).length) {
+            dispatch(acAddMetadata(programDimensionsMetadata))
+        }
     }
 
     useEffect(() => {
@@ -361,6 +474,12 @@ const App = () => {
             )
 
             addOptionSetsMetadata(visualization)
+            addTrackedEntityTypeMetadata(visualization)
+            addFixedDimensionsMetadata(visualization)
+            if (visualization.outputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+                addProgramDimensionsMetadata(visualization)
+                dispatch(acSetUiAccessoryPanelActiveTab())
+            }
 
             dispatch(
                 acAddParentGraphMap(
diff --git a/src/components/Dialogs/Conditions/AlphanumericCondition.js b/src/components/Dialogs/Conditions/AlphanumericCondition.js
index bfd9f3b16..c1c6545c1 100644
--- a/src/components/Dialogs/Conditions/AlphanumericCondition.js
+++ b/src/components/Dialogs/Conditions/AlphanumericCondition.js
@@ -83,7 +83,7 @@ const BaseCondition = ({
                             key={key}
                             value={key}
                             label={value}
-                            dataTest={'alphanumeric-condition-type'}
+                            dataTest="alphanumeric-condition-type"
                         />
                     )
                 )}
@@ -105,7 +105,7 @@ const BaseCondition = ({
                         onChange={({ checked }) => toggleCaseSensitive(checked)}
                         dense
                         className={classes.caseSensitiveCheckbox}
-                        dataTest={'condition-case-sensitive-checkbox'}
+                        dataTest="condition-case-sensitive-checkbox"
                     />
                 )}
             <Button
diff --git a/src/components/Dialogs/Conditions/ConditionsManager.js b/src/components/Dialogs/Conditions/ConditionsManager.js
index 93d8f45a2..2ae668548 100644
--- a/src/components/Dialogs/Conditions/ConditionsManager.js
+++ b/src/components/Dialogs/Conditions/ConditionsManager.js
@@ -33,7 +33,11 @@ import {
     parseConditionsArrayToString,
     parseConditionsStringToArray,
 } from '../../../modules/conditions.js'
-import { OUTPUT_TYPE_ENROLLMENT } from '../../../modules/visualization.js'
+import { extractDimensionIdParts } from '../../../modules/dimensionId.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../../../modules/visualization.js'
 import { sGetMetadataById } from '../../../reducers/metadata.js'
 import {
     sGetDimensionIdsFromLayout,
@@ -364,8 +368,9 @@ const ConditionsManager = ({
             selectedLegendSet)
 
     const isRepeatable =
-        inputType === OUTPUT_TYPE_ENROLLMENT &&
-        dimension.dimensionType === DIMENSION_TYPE_DATA_ELEMENT
+        [OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_TRACKED_ENTITY].includes(
+            inputType
+        ) && dimension.dimensionType === DIMENSION_TYPE_DATA_ELEMENT
 
     const renderConditions = () => (
         <>
@@ -472,12 +477,12 @@ const ConditionsManager = ({
                     </Tab>
                     {disableRepeatableTab ? (
                         <Tooltip
-                            key={`repeatable-tooltip`}
+                            key="repeatable-tooltip"
                             placement="bottom"
                             content={i18n.t(
                                 'Only available for repeatable stages'
                             )}
-                            dataTest={'repeatable-events-tooltip'}
+                            dataTest="repeatable-events-tooltip"
                         >
                             {repeatableTab}
                         </Tooltip>
@@ -537,10 +542,7 @@ const mapStateToProps = (state, ownProps) => ({
     stage:
         sGetMetadataById(
             state,
-            ownProps.dimension?.id?.substring(
-                0,
-                ownProps.dimension.id.indexOf('.')
-            )
+            extractDimensionIdParts(ownProps.dimension?.id)?.programStageId
         ) || {},
 })
 
diff --git a/src/components/Dialogs/Conditions/DateCondition.js b/src/components/Dialogs/Conditions/DateCondition.js
index 1337d4b61..01c0919e9 100644
--- a/src/components/Dialogs/Conditions/DateCondition.js
+++ b/src/components/Dialogs/Conditions/DateCondition.js
@@ -55,7 +55,7 @@ const BaseCondition = ({ condition, onChange, onRemove, type, max }) => {
                         key={key}
                         value={key}
                         label={value}
-                        dataTest={'date-condition-type'}
+                        dataTest="date-condition-type"
                     />
                 ))}
             </SingleSelectField>
diff --git a/src/components/Dialogs/Conditions/NumericCondition.js b/src/components/Dialogs/Conditions/NumericCondition.js
index 8afe30f93..ba91c1668 100644
--- a/src/components/Dialogs/Conditions/NumericCondition.js
+++ b/src/components/Dialogs/Conditions/NumericCondition.js
@@ -132,7 +132,7 @@ const NumericCondition = ({
                         key={key}
                         value={key}
                         label={value}
-                        dataTest={'numeric-condition-type'}
+                        dataTest="numeric-condition-type"
                     />
                 ))}
                 <MenuDivider dense />
@@ -141,7 +141,7 @@ const NumericCondition = ({
                     value={OPERATOR_IN}
                     label={i18n.t('is one of preset options')}
                     disabled={numberOfConditions > 1}
-                    dataTest={'numeric-condition-type'}
+                    dataTest="numeric-condition-type"
                 />
             </SingleSelectField>
             {operator &&
diff --git a/src/components/Dialogs/Conditions/OrgUnitCondition.js b/src/components/Dialogs/Conditions/OrgUnitCondition.js
index bce7e1927..fe94be4fc 100644
--- a/src/components/Dialogs/Conditions/OrgUnitCondition.js
+++ b/src/components/Dialogs/Conditions/OrgUnitCondition.js
@@ -67,7 +67,7 @@ const OrgUnitCondition = ({
             ].filter((path) => path)}
             selected={selected.path && [selected.path]}
             onChange={(item) => setValues(item)}
-            dataTest={'org-unit-tree'}
+            dataTest="org-unit-tree"
             singleSelection
         />
     )
diff --git a/src/components/Dialogs/Conditions/RepeatableEvents.js b/src/components/Dialogs/Conditions/RepeatableEvents.js
index b419dc75f..f04f6e1fc 100644
--- a/src/components/Dialogs/Conditions/RepeatableEvents.js
+++ b/src/components/Dialogs/Conditions/RepeatableEvents.js
@@ -8,7 +8,7 @@ import {
     getDefaultUiRepetition,
     PROP_MOST_RECENT,
     PROP_OLDEST,
-} from '../../../modules/ui.js'
+} from '../../../modules/repetition.js'
 import { sGetUiRepetitionByDimension } from '../../../reducers/ui.js'
 import commonClasses from '../styles/Common.module.css'
 import classes from './styles/ConditionsManager.module.css'
@@ -86,7 +86,7 @@ const RepeatableEvents = ({ dimensionId }) => {
                         value={mostRecent.toString()}
                         onChange={({ value }) => onMostRecentChange(value)}
                         min="0"
-                        dataTest={'most-recent-input'}
+                        dataTest="most-recent-input"
                     />
                 </div>
                 <div className={classes.repeatableWrapper}>
@@ -103,7 +103,7 @@ const RepeatableEvents = ({ dimensionId }) => {
                         value={oldest.toString()}
                         onChange={({ value }) => onOldestChange(value)}
                         min="0"
-                        dataTest={'oldest-input'}
+                        dataTest="oldest-input"
                     />
                 </div>
             </div>
diff --git a/src/components/Dialogs/DynamicDimension.js b/src/components/Dialogs/DynamicDimension.js
index 795bf97a9..15de30aee 100644
--- a/src/components/Dialogs/DynamicDimension.js
+++ b/src/components/Dialogs/DynamicDimension.js
@@ -194,7 +194,7 @@ const DynamicDimension = ({
 
     return dimension ? (
         <DimensionModal
-            dataTest={'dynamic-dimension-modal'}
+            dataTest="dynamic-dimension-modal"
             isInLayout={isInLayout}
             onClose={closeModal}
             title={dimension.name}
diff --git a/src/components/Dialogs/FixedDimension.js b/src/components/Dialogs/FixedDimension.js
index 1d5345ff7..bc90ee2fe 100644
--- a/src/components/Dialogs/FixedDimension.js
+++ b/src/components/Dialogs/FixedDimension.js
@@ -16,6 +16,10 @@ import {
     DIMENSION_ID_EVENT_STATUS,
     DIMENSION_ID_PROGRAM_STATUS,
 } from '../../modules/dimensionConstants.js'
+import {
+    extractDimensionIdParts,
+    formatDimensionId,
+} from '../../modules/dimensionId.js'
 import { removeLastPathSegment, getOuPath } from '../../modules/orgUnit.js'
 import {
     STATUS_ACTIVE,
@@ -29,6 +33,7 @@ import {
     sGetUiItemsByDimension,
     sGetUiParentGraphMap,
     sGetDimensionIdsFromLayout,
+    sGetUiInputType,
 } from '../../reducers/ui.js'
 import DimensionModal from './DimensionModal.js'
 import classes from './styles/Common.module.css'
@@ -40,21 +45,23 @@ const FixedDimension = ({
     dimension,
     isInLayout,
     metadata,
-    ouIds,
-    eventStatusIds,
-    programStatusIds,
     parentGraphMap,
     setUiItems,
+    selectedItemsIds,
+    inputType,
 }) => {
     const { rootOrgUnits } = useCachedDataQuery()
     const { serverVersion } = useConfig()
     const statusNames = getStatusNames()
+    const { programId, dimensionId } = extractDimensionIdParts(
+        dimension.id,
+        inputType
+    )
     const selectUiItems = ({ dimensionId, items }) => {
         setUiItems({
-            dimensionId,
+            dimensionId: dimension.id,
             itemIds: items.map((item) => item.id),
         })
-
         switch (dimensionId) {
             case DIMENSION_ID_ORGUNIT: {
                 const forMetadata = {}
@@ -93,22 +100,42 @@ const FixedDimension = ({
         </p>
     )
 
-    const setStatus = ({ dimensionId, selectedItemsIds, itemId, toggle }) => {
+    const setStatus = ({ selectedItemsIds, itemId, toggle }) => {
         const newIds = toggle
             ? [...new Set([...selectedItemsIds, itemId])]
             : selectedItemsIds.filter((id) => id !== itemId)
 
         selectUiItems({
-            dimensionId,
             items: newIds.map((id) => ({ id })),
         })
     }
 
     const renderProgramStatus = () => {
         const ALL_STATUSES = [
-            { id: STATUS_ACTIVE, name: statusNames[STATUS_ACTIVE] },
-            { id: STATUS_COMPLETED, name: statusNames[STATUS_COMPLETED] },
-            { id: STATUS_CANCELLED, name: statusNames[STATUS_CANCELLED] },
+            {
+                id: formatDimensionId({
+                    dimensionId: STATUS_ACTIVE,
+                    programId,
+                    outputType: inputType,
+                }),
+                name: statusNames[STATUS_ACTIVE],
+            },
+            {
+                id: formatDimensionId({
+                    dimensionId: STATUS_COMPLETED,
+                    programId,
+                    outputType: inputType,
+                }),
+                name: statusNames[STATUS_COMPLETED],
+            },
+            {
+                id: formatDimensionId({
+                    dimensionId: STATUS_CANCELLED,
+                    programId,
+                    outputType: inputType,
+                }),
+                name: statusNames[STATUS_CANCELLED],
+            },
         ]
 
         return (
@@ -118,19 +145,18 @@ const FixedDimension = ({
                     {ALL_STATUSES.map(({ id, name }) => (
                         <Checkbox
                             key={id}
-                            checked={programStatusIds.includes(id)}
+                            checked={selectedItemsIds.includes(id)}
                             label={name}
                             onChange={({ checked }) =>
                                 setStatus({
-                                    dimensionId: DIMENSION_ID_PROGRAM_STATUS,
-                                    selectedItemsIds: programStatusIds,
+                                    selectedItemsIds,
                                     itemId: id,
                                     toggle: checked,
                                 })
                             }
                             dense
                             className={classes.verticalCheckbox}
-                            dataTest={'program-status-checkbox'}
+                            dataTest="program-status-checkbox"
                         />
                     ))}
                 </div>
@@ -162,19 +188,18 @@ const FixedDimension = ({
                     {ALL_STATUSES.map(({ id, name }) => (
                         <Checkbox
                             key={id}
-                            checked={eventStatusIds.includes(id)}
+                            checked={selectedItemsIds.includes(id)}
                             label={name}
                             onChange={({ checked }) =>
                                 setStatus({
-                                    dimensionId: DIMENSION_ID_EVENT_STATUS,
-                                    selectedItemsIds: eventStatusIds,
+                                    selectedItemsIds,
                                     itemId: id,
                                     toggle: checked,
                                 })
                             }
                             dense
                             className={classes.verticalCheckbox}
-                            dataTest={'event-status-checkbox'}
+                            dataTest="event-status-checkbox"
                         />
                     ))}
                 </div>
@@ -183,7 +208,7 @@ const FixedDimension = ({
     }
 
     const renderModalContent = () => {
-        switch (dimension.id) {
+        switch (dimensionId) {
             case DIMENSION_ID_PROGRAM_STATUS:
                 return renderProgramStatus()
             case DIMENSION_ID_EVENT_STATUS:
@@ -193,7 +218,7 @@ const FixedDimension = ({
                     onSelect: selectUiItems,
                 }
 
-                const selected = ouIds // TODO: Refactor to not depend on the whole metadata object, but pass in full ouObjects (mapped with metadata) instead of just ids
+                const selected = selectedItemsIds
                     .filter(
                         (id) =>
                             metadata[ouIdHelper.removePrefix(id)] !== undefined
@@ -210,10 +235,10 @@ const FixedDimension = ({
                     })
 
                 const display =
-                    dimension.id === DIMENSION_ID_ORGUNIT ? 'block' : 'none'
+                    dimensionId === DIMENSION_ID_ORGUNIT ? 'block' : 'none'
 
                 return (
-                    <div key={DIMENSION_ID_ORGUNIT} style={{ display }}>
+                    <div key={dimension.id} style={{ display }}>
                         <OrgUnitDimension
                             selected={selected}
                             roots={rootOrgUnits.map(
@@ -242,13 +267,12 @@ const FixedDimension = ({
 
 FixedDimension.propTypes = {
     dimension: PropTypes.object.isRequired,
-    eventStatusIds: PropTypes.array.isRequired,
     isInLayout: PropTypes.bool.isRequired,
-    ouIds: PropTypes.array.isRequired,
-    programStatusIds: PropTypes.array.isRequired,
+    selectedItemsIds: PropTypes.array.isRequired,
     onClose: PropTypes.func.isRequired,
     addMetadata: PropTypes.func,
     addParentGraphMap: PropTypes.func,
+    inputType: PropTypes.string,
     metadata: PropTypes.object,
     parentGraphMap: PropTypes.object,
     setUiItems: PropTypes.func,
@@ -259,17 +283,13 @@ FixedDimension.defaultProps = {
 }
 
 const mapStateToProps = (state, ownProps) => ({
-    eventStatusIds: sGetUiItemsByDimension(state, DIMENSION_ID_EVENT_STATUS),
+    selectedItemsIds: sGetUiItemsByDimension(state, ownProps.dimension?.id),
     isInLayout: sGetDimensionIdsFromLayout(state).includes(
         ownProps.dimension?.id
     ),
+    inputType: sGetUiInputType(state),
     metadata: sGetMetadata(state),
-    ouIds: sGetUiItemsByDimension(state, DIMENSION_ID_ORGUNIT),
     parentGraphMap: sGetUiParentGraphMap(state),
-    programStatusIds: sGetUiItemsByDimension(
-        state,
-        DIMENSION_ID_PROGRAM_STATUS
-    ),
 })
 
 export default connect(mapStateToProps, {
diff --git a/src/components/Dialogs/PeriodDimension/PeriodDimension.js b/src/components/Dialogs/PeriodDimension/PeriodDimension.js
index b4b73498e..59a112247 100644
--- a/src/components/Dialogs/PeriodDimension/PeriodDimension.js
+++ b/src/components/Dialogs/PeriodDimension/PeriodDimension.js
@@ -17,6 +17,10 @@ import PropTypes from 'prop-types'
 import React, { useState, useMemo } from 'react'
 import { useDispatch, useSelector, useStore } from 'react-redux'
 import { acSetUiItems } from '../../../actions/ui.js'
+import {
+    extractDimensionIdParts,
+    formatDimensionId,
+} from '../../../modules/dimensionId.js'
 import {
     SYSTEM_SETTINGS_HIDE_DAILY_PERIODS,
     SYSTEM_SETTINGS_HIDE_WEEKLY_PERIODS,
@@ -28,6 +32,7 @@ import { USER_SETTINGS_UI_LOCALE } from '../../../modules/userSettings.js'
 import {
     sGetDimensionIdsFromLayout,
     sGetUiItemsByDimension,
+    sGetUiInputType,
 } from '../../../reducers/ui.js'
 import DimensionModal from '../DimensionModal.js'
 import styles from './PeriodDimension.module.css'
@@ -36,15 +41,18 @@ import { StartEndDate } from './StartEndDate.js'
 export const OPTION_PRESETS = 'PRESETS'
 export const OPTION_START_END_DATES = 'START_END_DATES'
 
-const isStartEndDate = (id) => {
-    const parts = id.split('_')
-    return (
-        parts.length === 2 &&
+const getStartEndDate = (id) => {
+    const { dimensionId: periodId } = extractDimensionIdParts(id)
+    const parts = periodId.split('_')
+    return parts.length === 2 &&
         !isNaN(Date.parse(parts[0])) &&
         !isNaN(Date.parse(parts[1]))
-    )
+        ? parts
+        : []
 }
 
+const isStartEndDate = (id) => getStartEndDate(id).length === 2
+
 const useIsInLayout = (dimensionId) => {
     const allDimensionIds = useSelector(sGetDimensionIdsFromLayout)
     return useMemo(
@@ -63,8 +71,7 @@ const useLocalizedStartEndDateFormatter = () => {
     )
     return (startEndDate) => {
         if (isStartEndDate(startEndDate)) {
-            return startEndDate
-                .split('_')
+            return getStartEndDate(startEndDate)
                 .map((dateStr) => formatter.format(new Date(dateStr)))
                 .join(' - ')
         } else {
@@ -110,18 +117,30 @@ export const PeriodDimension = ({ dimension, onClose }) => {
     const isInLayout = useIsInLayout(dimension?.id)
     const excludedPeriodTypes = useExcludedPeriods()
     const selectedIds = useSelector((state) =>
-        sGetUiItemsByDimension(state, dimension?.id)
+        sGetUiItemsByDimension(state, dimension?.id).map(
+            (id) => extractDimensionIdParts(id).dimensionId
+        )
     )
+
     const [entryMethod, setEntryMethod] = useState(
         selectedIds.filter((id) => isStartEndDate(id)).length
             ? OPTION_START_END_DATES
             : OPTION_PRESETS
     )
 
+    const outputType = useSelector(sGetUiInputType)
+
+    const { programId } = extractDimensionIdParts(dimension.id, outputType)
+
     const updatePeriodDimensionItems = (items) => {
         const { uiItems, metadata } = items.reduce(
             (acc, item) => {
-                acc.uiItems.push(item.id)
+                const id = formatDimensionId({
+                    dimensionId: item.id,
+                    programId,
+                    outputType,
+                })
+                acc.uiItems.push(id)
 
                 if (isStartEndDate(item.id)) {
                     acc.metadata[item.id] = {
@@ -146,31 +165,35 @@ export const PeriodDimension = ({ dimension, onClose }) => {
     }
 
     const onSegmentedControlChange = ({ value }) => {
-        setEntryMethod(value)
-        updatePeriodDimensionItems([])
+        if (value !== entryMethod) {
+            setEntryMethod(value)
+            updatePeriodDimensionItems([])
+        }
     }
 
     return dimension ? (
         <DimensionModal
-            dataTest={'period-dimension-modal'}
+            dataTest="period-dimension-modal"
             isInLayout={isInLayout}
             onClose={onClose}
             title={dimension.name}
         >
-            <SegmentedControl
-                options={[
-                    {
-                        label: i18n.t('Choose from presets'),
-                        value: OPTION_PRESETS,
-                    },
-                    {
-                        label: i18n.t('Define start - end dates'),
-                        value: OPTION_START_END_DATES,
-                    },
-                ]}
-                selected={entryMethod}
-                onChange={onSegmentedControlChange}
-            ></SegmentedControl>
+            <div className={styles.navigation}>
+                <SegmentedControl
+                    options={[
+                        {
+                            label: i18n.t('Choose from presets'),
+                            value: OPTION_PRESETS,
+                        },
+                        {
+                            label: i18n.t('Define start - end dates'),
+                            value: OPTION_START_END_DATES,
+                        },
+                    ]}
+                    selected={entryMethod}
+                    onChange={onSegmentedControlChange}
+                ></SegmentedControl>
+            </div>
             <div className={styles.entry}>
                 {entryMethod === OPTION_PRESETS && (
                     <BasePeriodDimension
@@ -186,7 +209,7 @@ export const PeriodDimension = ({ dimension, onClose }) => {
                 )}
                 {entryMethod === OPTION_START_END_DATES && (
                     <StartEndDate
-                        value={selectedIds[0] || ''}
+                        value={getStartEndDate(selectedIds[0] || '')}
                         setValue={(value) => {
                             if (!value && selectedIds.length) {
                                 updatePeriodDimensionItems([])
diff --git a/src/components/Dialogs/PeriodDimension/PeriodDimension.module.css b/src/components/Dialogs/PeriodDimension/PeriodDimension.module.css
index 723d37fae..fab1e0545 100644
--- a/src/components/Dialogs/PeriodDimension/PeriodDimension.module.css
+++ b/src/components/Dialogs/PeriodDimension/PeriodDimension.module.css
@@ -3,3 +3,7 @@
     margin-top: var(--spacers-dp8);
     padding-top: var(--spacers-dp12);
 }
+
+.navigation {
+    flex-grow: 0;
+}
diff --git a/src/components/Dialogs/PeriodDimension/StartEndDate.js b/src/components/Dialogs/PeriodDimension/StartEndDate.js
index d786d99cf..0dc8b54d8 100644
--- a/src/components/Dialogs/PeriodDimension/StartEndDate.js
+++ b/src/components/Dialogs/PeriodDimension/StartEndDate.js
@@ -4,8 +4,10 @@ import PropTypes from 'prop-types'
 import React, { useEffect, useState } from 'react'
 import styles from './StartEndDate.module.css'
 
-export const StartEndDate = ({ value, setValue }) => {
-    const [startDateStr, endDateStr] = value ? value.split('_') : []
+export const StartEndDate = ({
+    value: [startDateStr, endDateStr],
+    setValue,
+}) => {
     const [startDate, setStartDate] = useState(startDateStr)
     const [endDate, setEndDate] = useState(endDateStr)
 
@@ -34,7 +36,7 @@ export const StartEndDate = ({ value, setValue }) => {
                     label={i18n.t('Start date')}
                     inputWidth="200px"
                     max="9999-12-31"
-                    dataTest={'start-date-input'}
+                    dataTest="start-date-input"
                 />
                 <div className={styles.icon}>
                     <IconArrowRight16 color={colors.grey500} />
@@ -46,7 +48,7 @@ export const StartEndDate = ({ value, setValue }) => {
                     label={i18n.t('End date')}
                     inputWidth="200px"
                     max="9999-12-31"
-                    dataTest={'end-date-input'}
+                    dataTest="end-date-input"
                 />
             </div>
         </Field>
@@ -54,5 +56,5 @@ export const StartEndDate = ({ value, setValue }) => {
 }
 StartEndDate.propTypes = {
     setValue: PropTypes.func.isRequired,
-    value: PropTypes.string.isRequired,
+    value: PropTypes.array.isRequired,
 }
diff --git a/src/components/Dialogs/common/TransferLeftHeader.js b/src/components/Dialogs/common/TransferLeftHeader.js
index 72c08713d..1d6d603bd 100644
--- a/src/components/Dialogs/common/TransferLeftHeader.js
+++ b/src/components/Dialogs/common/TransferLeftHeader.js
@@ -16,7 +16,7 @@ export const TransferLeftHeader = ({ searchTerm, setSearchTerm, dataTest }) => (
             dataTest={`${dataTest}-filter-input-field`}
             dense
             initialFocus
-            type={'search'}
+            type="search"
         />
     </div>
 )
diff --git a/src/components/DndContext.js b/src/components/DndContext.js
index 7c8df1268..56355b030 100644
--- a/src/components/DndContext.js
+++ b/src/components/DndContext.js
@@ -17,7 +17,7 @@ import {
     acSetUiDraggingId,
 } from '../actions/ui.js'
 import { getConditionsTexts } from '../modules/conditions.js'
-import { extractDimensionIdParts } from '../modules/utils.js'
+import { extractDimensionIdParts } from '../modules/dimensionId.js'
 import { sGetMetadata } from '../reducers/metadata.js'
 import {
     sGetUiLayout,
@@ -25,6 +25,7 @@ import {
     sGetUiDraggingId,
     sGetUiConditionsByDimension,
     sGetUiOptions,
+    sGetUiInputType,
 } from '../reducers/ui.js'
 import styles from './DndContext.module.css'
 import { ChipBase } from './Layout/ChipBase.js'
@@ -123,6 +124,7 @@ const OuterDndContext = ({ children }) => {
     const id = draggingId ? getIdFromDraggingId(draggingId) : null
 
     const layout = useSelector(sGetUiLayout)
+    const inputType = useSelector(sGetUiInputType)
     const metadata = useSelector(sGetMetadata)
     const chipItems = useSelector((state) => sGetUiItemsByDimension(state, id))
     const chipConditions = useSelector((state) =>
@@ -191,6 +193,8 @@ const OuterDndContext = ({ children }) => {
                     dimension={dimension}
                     conditionsLength={conditionsTexts.length}
                     itemsLength={chipItems.length}
+                    inputType={inputType}
+                    axisId={sourceAxis}
                 />
             </div>
         )
diff --git a/src/components/DownloadMenu/useDownload.js b/src/components/DownloadMenu/useDownload.js
index 451aef099..3946f2a29 100644
--- a/src/components/DownloadMenu/useDownload.js
+++ b/src/components/DownloadMenu/useDownload.js
@@ -4,12 +4,15 @@ import { useCallback } from 'react'
 import { useSelector } from 'react-redux'
 import { validateLineListLayout } from '../../modules/layoutValidation.js'
 import { isAoWithTimeDimension } from '../../modules/timeDimensions.js'
-import { OUTPUT_TYPE_ENROLLMENT } from '../../modules/visualization.js'
+import {
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../../modules/visualization.js'
 import { sGetCurrent } from '../../reducers/current.js'
 import {
-    getAnalyticsEndpoint,
     getAdaptedVisualization,
-} from '../Visualization/useAnalyticsData.js'
+    getAnalyticsEndpoint,
+} from '../Visualization/analyticsQueryTools.js'
 import {
     DOWNLOAD_TYPE_PLAIN,
     ID_SCHEME_NAME,
@@ -31,21 +34,36 @@ const useDownload = (relativePeriodDate) => {
                 return false
             }
 
-            let req = new analyticsEngine.request()
             let target = '_top'
 
             const { adaptedVisualization, headers, parameters } =
                 getAdaptedVisualization(current)
-            const path = `${getAnalyticsEndpoint(current.outputType)}/query`
+
+            let req = new analyticsEngine.request()
+                .withPath(`${getAnalyticsEndpoint(current.outputType)}/query`)
+                .withFormat(format)
+
+            switch (current.outputType) {
+                case OUTPUT_TYPE_TRACKED_ENTITY:
+                    req = req.withTrackedEntityType(
+                        current.trackedEntityType.id
+                    )
+                    break
+                default:
+                    req = req
+                        .withProgram(current.program.id)
+                        .withOutputType(current.outputType)
+                    break
+            }
+
+            if (current.outputType === OUTPUT_TYPE_EVENT) {
+                req = req.withStage(current.programStage?.id)
+            }
 
             switch (type) {
                 case DOWNLOAD_TYPE_TABLE:
                     req = req
                         .fromVisualization(adaptedVisualization)
-                        .withProgram(current.program.id)
-                        .withOutputType(current.outputType)
-                        .withPath(path)
-                        .withFormat(format)
                         .withTableLayout()
                         .withColumns(
                             current.columns
@@ -82,10 +100,6 @@ const useDownload = (relativePeriodDate) => {
                     req = req
                         // Perhaps the 2nd arg `passFilterAsDimension` should be false for the advanced submenu?
                         .fromVisualization(adaptedVisualization, true)
-                        .withProgram(current.program.id)
-                        .withOutputType(current.outputType)
-                        .withPath(path)
-                        .withFormat(format)
                         .withParameters({
                             ...parameters,
                             headers,
@@ -128,10 +142,6 @@ const useDownload = (relativePeriodDate) => {
             // TODO add common parameters
             // if there are for both event/enrollment and PT/LL
 
-            if (current.outputType !== OUTPUT_TYPE_ENROLLMENT) {
-                req = req.withStage(current.programStage?.id)
-            }
-
             if (relativePeriodDate && isAoWithTimeDimension(current)) {
                 req = req.withRelativePeriodDate(relativePeriodDate)
             }
diff --git a/src/components/Layout/Chip.js b/src/components/Layout/Chip.js
index 6094f7d01..a613eef9c 100644
--- a/src/components/Layout/Chip.js
+++ b/src/components/Layout/Chip.js
@@ -13,6 +13,7 @@ import {
     sGetUiItemsByDimension,
     sGetUiConditionsByDimension,
     sGetUiOptions,
+    sGetUiInputType,
 } from '../../reducers/ui.js'
 import DimensionMenu from '../DimensionMenu/DimensionMenu.js'
 import { ChipBase } from './ChipBase.js'
@@ -53,6 +54,7 @@ const Chip = ({
     })
 
     const metadata = useSelector(sGetMetadata)
+    const inputType = useSelector(sGetUiInputType)
     const { digitGroupSeparator } = useSelector(sGetUiOptions)
     const conditions = useSelector((state) =>
         sGetUiConditionsByDimension(state, dimension.id)
@@ -106,6 +108,7 @@ const Chip = ({
         <TooltipContent
             dimension={dimension}
             conditionsTexts={conditionsTexts}
+            axisId={axisId}
         />
     )
 
@@ -135,6 +138,7 @@ const Chip = ({
                         <Tooltip
                             content={renderTooltipContent()}
                             placement="bottom"
+                            dataTest="layout-chip-tooltip"
                         >
                             {({ ref, onMouseOver, onMouseOut }) => (
                                 <div
@@ -150,7 +154,8 @@ const Chip = ({
                                             conditionsTexts.length
                                         }
                                         itemsLength={items.length}
-                                        metadata={metadata}
+                                        inputType={inputType}
+                                        axisId={axisId}
                                     />
                                 </div>
                             )}
diff --git a/src/components/Layout/ChipBase.js b/src/components/Layout/ChipBase.js
index e67c53598..5c65758da 100644
--- a/src/components/Layout/ChipBase.js
+++ b/src/components/Layout/ChipBase.js
@@ -1,4 +1,5 @@
 import {
+    AXIS_ID_FILTERS,
     DIMENSION_ID_ORGUNIT,
     DIMENSION_TYPE_PERIOD,
     VALUE_TYPE_BOOLEAN,
@@ -8,6 +9,7 @@ import i18n from '@dhis2/d2-i18n'
 import cx from 'classnames'
 import PropTypes from 'prop-types'
 import React from 'react'
+import { OUTPUT_TYPE_TRACKED_ENTITY } from '../../modules/visualization.js'
 import { DimensionIcon } from '../MainSidebar/DimensionItem/DimensionIcon.js'
 import styles from './styles/Chip.module.css'
 
@@ -16,13 +18,19 @@ const VALUE_TYPE_BOOLEAN_NUM_OPTIONS = 3
 
 // Presentational component used by dnd - do not add redux or dnd functionality
 
-export const ChipBase = ({ dimension, conditionsLength, itemsLength }) => {
-    const { id, name, dimensionType, optionSet, valueType, stageName } =
-        dimension
+export const ChipBase = ({
+    dimension,
+    conditionsLength,
+    itemsLength,
+    inputType,
+    axisId,
+}) => {
+    const { id, name, dimensionType, optionSet, valueType, suffix } = dimension
 
-    const getChipSuffix = () => {
+    const getChipItems = () => {
         if (
-            (id === DIMENSION_ID_ORGUNIT ||
+            ((inputType !== OUTPUT_TYPE_TRACKED_ENTITY &&
+                id === DIMENSION_ID_ORGUNIT) ||
                 dimensionType === DIMENSION_TYPE_PERIOD) &&
             !itemsLength
         ) {
@@ -31,15 +39,16 @@ export const ChipBase = ({ dimension, conditionsLength, itemsLength }) => {
 
         const all = i18n.t('all')
 
-        if (!conditionsLength && !itemsLength) {
+        if (!conditionsLength && !itemsLength && axisId !== AXIS_ID_FILTERS) {
             return all
         }
 
         if (
-            (valueType === VALUE_TYPE_TRUE_ONLY &&
+            ((valueType === VALUE_TYPE_TRUE_ONLY &&
                 conditionsLength === VALUE_TYPE_TRUE_ONLY_NUM_OPTIONS) ||
-            (valueType === VALUE_TYPE_BOOLEAN &&
-                conditionsLength === VALUE_TYPE_BOOLEAN_NUM_OPTIONS)
+                (valueType === VALUE_TYPE_BOOLEAN &&
+                    conditionsLength === VALUE_TYPE_BOOLEAN_NUM_OPTIONS)) &&
+            axisId !== AXIS_ID_FILTERS
         ) {
             return all
         }
@@ -51,7 +60,7 @@ export const ChipBase = ({ dimension, conditionsLength, itemsLength }) => {
         }
     }
 
-    const suffix = getChipSuffix()
+    const chipItems = getChipItems()
 
     return (
         <div className={cx(styles.chipBase)}>
@@ -60,16 +69,16 @@ export const ChipBase = ({ dimension, conditionsLength, itemsLength }) => {
             </div>
             <span className={styles.label}>
                 <span className={styles.primary}>{name}</span>
-                {stageName && (
+                {suffix && (
                     <>
                         <span>,</span>
-                        <span className={styles.secondary}>{stageName}</span>
+                        <span className={styles.secondary}>{suffix}</span>
                     </>
                 )}
             </span>
-            {suffix && (
-                <span className={styles.suffix} data-test="chip-suffix">
-                    {suffix}
+            {chipItems && (
+                <span className={styles.items} data-test="chip-items">
+                    {chipItems}
                 </span>
             )}
         </div>
@@ -77,14 +86,16 @@ export const ChipBase = ({ dimension, conditionsLength, itemsLength }) => {
 }
 
 ChipBase.propTypes = {
+    axisId: PropTypes.string,
     conditionsLength: PropTypes.number,
     dimension: PropTypes.shape({
         dimensionType: PropTypes.string,
         id: PropTypes.string,
         name: PropTypes.string,
         optionSet: PropTypes.string,
-        stageName: PropTypes.string,
+        suffix: PropTypes.string,
         valueType: PropTypes.string,
     }),
+    inputType: PropTypes.string,
     itemsLength: PropTypes.number,
 }
diff --git a/src/components/Layout/DefaultLayout/DefaultAxis.js b/src/components/Layout/DefaultLayout/DefaultAxis.js
index cd221cd52..2eaaff946 100644
--- a/src/components/Layout/DefaultLayout/DefaultAxis.js
+++ b/src/components/Layout/DefaultLayout/DefaultAxis.js
@@ -1,20 +1,17 @@
-import { DIMENSION_TYPE_DATA_ELEMENT } from '@dhis2/analytics'
 import { useDroppable } from '@dnd-kit/core'
 import { SortableContext } from '@dnd-kit/sortable'
 import cx from 'classnames'
 import PropTypes from 'prop-types'
-import React, { useMemo } from 'react'
+import React from 'react'
 import { useSelector, useDispatch } from 'react-redux'
 import { acSetUiOpenDimensionModal } from '../../../actions/ui.js'
 import { getAxisName } from '../../../modules/axis.js'
-import { extractDimensionIdParts } from '../../../modules/utils.js'
-import { OUTPUT_TYPE_ENROLLMENT } from '../../../modules/visualization.js'
-import { sGetMetadata, sGetMetadataById } from '../../../reducers/metadata.js'
+import { getDimensionsWithSuffix } from '../../../modules/getDimensionsWithSuffix.js'
+import { sGetMetadata } from '../../../reducers/metadata.js'
 import {
     sGetUiDraggingId,
     sGetUiDimensionIdsByAxisId,
     sGetUiInputType,
-    sGetUiProgramId,
     renderChipsSelector,
 } from '../../../reducers/ui.js'
 import { LAST, getDropzoneId } from '../../DndContext.js'
@@ -36,68 +33,6 @@ const DefaultAxis = ({ axisId, className }) => {
     const draggingId = useSelector(sGetUiDraggingId)
     const metadata = useSelector(sGetMetadata)
     const inputType = useSelector(sGetUiInputType)
-    const selectedProgramId = useSelector(sGetUiProgramId)
-    const program = useSelector((state) =>
-        sGetMetadataById(state, selectedProgramId)
-    )
-
-    const programStageNames = useMemo(
-        () =>
-            program?.programStages?.reduce((acc, stage) => {
-                acc.set(stage.id, stage.name)
-                return acc
-            }, new Map()),
-        [program]
-    )
-
-    const getDimensionsWithStageName = () => {
-        let hasDuplicates = false
-        const dataElements = new Map()
-
-        const dimensions = dimensionIds.map((id) => {
-            let dimension = {}
-            if (metadata[id]) {
-                dimension = { ...metadata[id] }
-            } else {
-                const { dimensionId } = extractDimensionIdParts(id)
-                dimension = { ...metadata[dimensionId] }
-            }
-            return dimension
-        })
-
-        if (inputType === OUTPUT_TYPE_ENROLLMENT) {
-            dimensions.forEach((dimension) => {
-                const { dimensionId } = extractDimensionIdParts(dimension.id)
-                if (
-                    dimension.dimensionType === DIMENSION_TYPE_DATA_ELEMENT &&
-                    dimensionId
-                ) {
-                    const dataElementCount = dataElements.get(dimensionId)
-
-                    if (dataElementCount) {
-                        dataElements.set(dimensionId, dataElementCount + 1)
-                        hasDuplicates = true
-                    } else {
-                        dataElements.set(dimensionId, 1)
-                    }
-                }
-            })
-
-            return hasDuplicates
-                ? dimensions.map((dimension) => {
-                      const { dimensionId, programStageId } =
-                          extractDimensionIdParts(dimension.id)
-                      if (dimensionId && dataElements.get(dimensionId) > 1) {
-                          dimension.stageName =
-                              programStageNames?.get(programStageId)
-                      }
-                      return dimension
-                  })
-                : dimensions
-        }
-
-        return dimensions
-    }
 
     const activeIndex = draggingId ? dimensionIds.indexOf(draggingId) : -1
 
@@ -118,7 +53,11 @@ const DefaultAxis = ({ axisId, className }) => {
                             overLastDropZone={overLastDropZone}
                         />
                         {renderChips &&
-                            getDimensionsWithStageName().map((dimension, i) => (
+                            getDimensionsWithSuffix({
+                                dimensionIds,
+                                metadata,
+                                inputType,
+                            }).map((dimension, i) => (
                                 <Chip
                                     key={`${axisId}-${dimension.id}`}
                                     onClick={() =>
diff --git a/src/components/Layout/TooltipContent.js b/src/components/Layout/TooltipContent.js
index 48b4f48c7..933abec46 100644
--- a/src/components/Layout/TooltipContent.js
+++ b/src/components/Layout/TooltipContent.js
@@ -6,23 +6,33 @@ import {
     DIMENSION_TYPE_ORGANISATION_UNIT,
     DIMENSION_TYPE_PERIOD,
     DIMENSION_TYPE_ORGANISATION_UNIT_GROUP_SET,
+    AXIS_ID_FILTERS,
 } from '@dhis2/analytics'
 import i18n from '@dhis2/d2-i18n'
 import PropTypes from 'prop-types'
 import React from 'react'
 import { useSelector } from 'react-redux'
 import { DIMENSION_TYPE_STATUS } from '../../modules/dimensionConstants.js'
+import { extractDimensionIdParts } from '../../modules/dimensionId.js'
 import { sGetMetadata } from '../../reducers/metadata.js'
-import { sGetUiItemsByDimension } from '../../reducers/ui.js'
+import { sGetUiInputType, sGetUiItemsByDimension } from '../../reducers/ui.js'
 import styles from './styles/Tooltip.module.css'
 
 const renderLimit = 5
 
-export const TooltipContent = ({ dimension, conditionsTexts }) => {
+export const TooltipContent = ({ dimension, conditionsTexts, axisId }) => {
     const metadata = useSelector(sGetMetadata)
+    const inputType = useSelector(sGetUiInputType)
     const itemIds = useSelector((state) =>
         sGetUiItemsByDimension(state, dimension.id)
     )
+    const { programStageId, programId } = extractDimensionIdParts(
+        dimension.id,
+        inputType
+    )
+
+    const stageName = dimension.stageName || metadata[programStageId]?.name
+    const programName = metadata[programId]?.name
 
     const getNameList = (idList, label, metadata) =>
         idList.reduce(
@@ -33,16 +43,6 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
             `${label}: `
         )
 
-    let stageName
-    if (dimension.stageName) {
-        stageName = dimension.stageName
-    } else {
-        const stageId =
-            dimension.id.indexOf('.') !== -1 &&
-            dimension.id.substring(0, dimension.id.indexOf('.'))
-        stageName = metadata[stageId]?.name
-    }
-
     const getItemDisplayNames = () => {
         const levelIds = []
         const groupIds = []
@@ -54,7 +54,10 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
             } else if (ouIdHelper.hasGroupPrefix(id)) {
                 groupIds.push(ouIdHelper.removePrefix(id))
             } else {
-                itemDisplayNames.push(metadata[id] ? metadata[id].name : id)
+                const { dimensionId } = extractDimensionIdParts(id, inputType)
+                itemDisplayNames.push(
+                    metadata[dimensionId] ? metadata[dimensionId].name : id
+                )
             }
         })
 
@@ -108,11 +111,44 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
         </li>
     )
 
-    const renderAllItemsLabel = () => (
-        <li key={`${dimension.id}-all-selected`} className={styles.item}>
-            {i18n.t('Showing all values for this dimension')}
-        </li>
-    )
+    const renderStageName = () =>
+        stageName && (
+            <li className={styles.item}>
+                {i18n.t('Program stage: {{- stageName}}', {
+                    stageName,
+                    nsSeparator: '^^',
+                })}
+            </li>
+        )
+
+    const renderProgramName = () =>
+        programName && (
+            <li className={styles.item}>
+                {i18n.t('Program: {{- programName}}', {
+                    programName,
+                    nsSeparator: '^^',
+                })}
+            </li>
+        )
+
+    const renderItemsSection = (itemsList) => {
+        if (itemsList.length) {
+            return renderItems(itemsList)
+        } else {
+            if (axisId === AXIS_ID_FILTERS) {
+                return renderNoItemsLabel()
+            } else {
+                return (
+                    <li
+                        key={`${dimension.id}-all-selected`}
+                        className={styles.item}
+                    >
+                        {i18n.t('Showing all values for this dimension')}
+                    </li>
+                )
+            }
+        }
+    }
 
     const itemDisplayNames = Boolean(itemIds.length) && getItemDisplayNames()
 
@@ -123,16 +159,15 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
         case DIMENSION_TYPE_STATUS:
             return (
                 <ul className={styles.list} data-test="tooltip-content">
-                    {itemDisplayNames
-                        ? renderItems(itemDisplayNames)
-                        : renderAllItemsLabel()}
+                    {renderProgramName()}
+                    {renderItemsSection(itemDisplayNames)}
                 </ul>
             )
-
         case DIMENSION_TYPE_PERIOD:
         case DIMENSION_TYPE_ORGANISATION_UNIT:
             return (
                 <ul className={styles.list} data-test="tooltip-content">
+                    {renderProgramName()}
                     {itemDisplayNames
                         ? renderItems(itemDisplayNames)
                         : renderNoItemsLabel()}
@@ -141,26 +176,17 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
         case DIMENSION_TYPE_DATA_ELEMENT: {
             return (
                 <ul className={styles.list} data-test="tooltip-content">
-                    {stageName && (
-                        <li className={styles.item}>
-                            {i18n.t('Program stage: {{- stageName}}', {
-                                stageName,
-                                nsSeparator: '^^',
-                            })}
-                        </li>
-                    )}
-                    {conditionsTexts.length
-                        ? renderItems(conditionsTexts)
-                        : renderAllItemsLabel()}
+                    {renderProgramName()}
+                    {renderStageName()}
+                    {renderItemsSection(conditionsTexts)}
                 </ul>
             )
         }
         default: {
             return (
                 <ul className={styles.list} data-test="tooltip-content">
-                    {conditionsTexts.length
-                        ? renderItems(conditionsTexts)
-                        : renderAllItemsLabel()}
+                    {renderProgramName()}
+                    {renderItemsSection(conditionsTexts)}
                 </ul>
             )
         }
@@ -170,6 +196,7 @@ export const TooltipContent = ({ dimension, conditionsTexts }) => {
 TooltipContent.propTypes = {
     conditionsTexts: PropTypes.array.isRequired,
     dimension: PropTypes.object.isRequired,
+    axisId: PropTypes.string,
 }
 
 export default TooltipContent
diff --git a/src/components/Layout/__tests__/TooltipContent.spec.js b/src/components/Layout/__tests__/TooltipContent.spec.js
index 9a8778c2c..9cea6cc8c 100644
--- a/src/components/Layout/__tests__/TooltipContent.spec.js
+++ b/src/components/Layout/__tests__/TooltipContent.spec.js
@@ -2,14 +2,22 @@ import { render } from '@testing-library/react'
 import React from 'react'
 import { Provider } from 'react-redux'
 import configureMockStore from 'redux-mock-store'
+import { OUTPUT_TYPE_EVENT } from '../../../modules/visualization.js'
 import { TooltipContent } from '../TooltipContent.js'
 
 const mockStore = configureMockStore()
 
+const inputTypeEvent = {
+    input: {
+        type: OUTPUT_TYPE_EVENT,
+    },
+}
+
 describe('TooltipContent', () => {
     test('OU: 1 id and 1 level', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {
                     ou: ['theOuId', 'LEVEL-level1Id'],
                 },
@@ -39,6 +47,7 @@ describe('TooltipContent', () => {
     test('OU: 1 id and 1 level, and missing metadata', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {
                     ou: ['theOuId', 'LEVEL-level1Id'],
                 },
@@ -65,6 +74,7 @@ describe('TooltipContent', () => {
     test('OU: 1 id and 3 groups', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {
                     ou: [
                         'theOuId',
@@ -100,7 +110,7 @@ describe('TooltipContent', () => {
     })
     test('OU: none selected', () => {
         const store = {
-            ui: { itemsByDimension: {} },
+            ui: { ...inputTypeEvent, itemsByDimension: {} },
             metadata: {},
         }
 
@@ -122,7 +132,7 @@ describe('TooltipContent', () => {
     })
     test('Period: none selected', () => {
         const store = {
-            ui: { itemsByDimension: {} },
+            ui: { ...inputTypeEvent, itemsByDimension: {} },
             metadata: {
                 eventDate: { name: 'Report compilation date' },
             },
@@ -147,6 +157,7 @@ describe('TooltipContent', () => {
     test('Period: 2 selected', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {
                     eventDate: ['202205', '202207'],
                 },
@@ -182,6 +193,7 @@ describe('TooltipContent', () => {
     test('COGS: 2 items', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {
                     COGS_id: ['cogs1Id', 'cogs2Id'],
                 },
@@ -219,6 +231,7 @@ describe('TooltipContent', () => {
     test('Data element: optionSet, 2 conditions but name missing for one', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {},
             },
             metadata: {},
@@ -246,6 +259,7 @@ describe('TooltipContent', () => {
     test('Data element: with stage and 1 condition', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {},
             },
             metadata: {
@@ -274,7 +288,7 @@ describe('TooltipContent', () => {
     })
     test('Data element: no conditions', () => {
         const store = {
-            ui: { itemsByDimension: {} },
+            ui: { ...inputTypeEvent, itemsByDimension: {} },
             metadata: {},
         }
 
@@ -298,6 +312,7 @@ describe('TooltipContent', () => {
     test('Data element: 2 conditions', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {},
             },
             metadata: {},
@@ -323,6 +338,7 @@ describe('TooltipContent', () => {
     test('Data element: 6 conditions', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {},
             },
             metadata: {},
@@ -357,6 +373,7 @@ describe('TooltipContent', () => {
     test('Data element: 8 conditions', () => {
         const store = {
             ui: {
+                ...inputTypeEvent,
                 itemsByDimension: {},
             },
             metadata: {},
diff --git a/src/components/Layout/__tests__/__snapshots__/ChipBase.spec.js.snap b/src/components/Layout/__tests__/__snapshots__/ChipBase.spec.js.snap
index 3197f1c33..daa342cc8 100644
--- a/src/components/Layout/__tests__/__snapshots__/ChipBase.spec.js.snap
+++ b/src/components/Layout/__tests__/__snapshots__/ChipBase.spec.js.snap
@@ -30,8 +30,8 @@ exports[`ChipBase Data element: 2 conditions 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       2
     </span>
@@ -69,8 +69,8 @@ exports[`ChipBase Data element: TRUE_ONLY 1 condition 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       1
     </span>
@@ -108,8 +108,8 @@ exports[`ChipBase Data element: TRUE_ONLY both selected 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       all
     </span>
@@ -147,8 +147,8 @@ exports[`ChipBase Data element: TRUE_ONLY no conditions 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       all
     </span>
@@ -184,18 +184,10 @@ exports[`ChipBase Data element: in stage with option set and 2 options chosen 1`
       >
         My data element
       </span>
-      <span>
-        ,
-      </span>
-      <span
-        class="secondary"
-      >
-        Stage 1
-      </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       2
     </span>
@@ -233,8 +225,8 @@ exports[`ChipBase Data element: no conditions 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       all
     </span>
@@ -272,8 +264,8 @@ exports[`ChipBase Data element: option set and 2 options chosen 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       2
     </span>
@@ -311,8 +303,8 @@ exports[`ChipBase OU: 2 selected 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       2
     </span>
@@ -383,8 +375,8 @@ exports[`ChipBase Period: 1 selected 1`] = `
       </span>
     </span>
     <span
-      class="suffix"
-      data-test="chip-suffix"
+      class="items"
+      data-test="chip-items"
     >
       1
     </span>
diff --git a/src/components/Layout/styles/Chip.module.css b/src/components/Layout/styles/Chip.module.css
index bcdb32d8e..aa53986f9 100644
--- a/src/components/Layout/styles/Chip.module.css
+++ b/src/components/Layout/styles/Chip.module.css
@@ -55,7 +55,7 @@
     white-space: nowrap;
 }
 
-.suffix {
+.items {
     white-space: nowrap;
     flex-shrink: 0;
     font-family: monospace;
diff --git a/src/components/MainSidebar/DimensionsList/DimensionsList.js b/src/components/MainSidebar/DimensionsList/DimensionsList.js
index dd4cfd5ab..060a04162 100644
--- a/src/components/MainSidebar/DimensionsList/DimensionsList.js
+++ b/src/components/MainSidebar/DimensionsList/DimensionsList.js
@@ -6,16 +6,23 @@ import { DimensionItem } from '../DimensionItem/index.js'
 import { useSelectedDimensions } from '../SelectedDimensionsContext.js'
 import styles from './DimensionsList.module.css'
 
-const getNoResultsMessage = (searchTerm, programName) => {
+const getNoResultsMessage = ({
+    searchTerm,
+    programName,
+    trackedEntityType,
+}) => {
     if (searchTerm) {
         return i18n.t("No dimensions found for '{{- searchTerm}}'", {
             searchTerm,
         })
-    }
-    if (programName) {
+    } else if (programName) {
         return i18n.t('No dimensions found in the {{- programName}} program', {
             programName,
         })
+    } else if (trackedEntityType) {
+        return i18n.t(' {{- trackedEntityType}} has no dimensions', {
+            trackedEntityType,
+        })
     }
     return i18n.t('No dimensions found')
 }
@@ -32,6 +39,7 @@ const DimensionsList = ({
     searchTerm,
     setIsListEndVisible,
     dataTest,
+    trackedEntityType,
 }) => {
     const scrollBoxRef = useRef()
     const { getIsDimensionSelected } = useSelectedDimensions()
@@ -63,10 +71,14 @@ const DimensionsList = ({
         )
     }
 
-    if (!dimensions?.length) {
+    if (!loading && !fetching && !dimensions?.length) {
         return (
             <div className={styles.noResults}>
-                {getNoResultsMessage(searchTerm, programName)}
+                {getNoResultsMessage({
+                    searchTerm,
+                    programName,
+                    trackedEntityType,
+                })}
             </div>
         )
     }
@@ -81,7 +93,7 @@ const DimensionsList = ({
             onMouseDown={(event) => event.preventDefault()}
             ref={scrollBoxRef}
         >
-            <div className={styles.list}>
+            <div className={styles.list} data-test={`${dataTest}-list`}>
                 {dimensions.map((dimension) => (
                     <DimensionItem
                         key={dimension.id}
@@ -111,6 +123,7 @@ DimensionsList.propTypes = {
     loading: PropTypes.bool,
     programName: PropTypes.string,
     searchTerm: PropTypes.string,
+    trackedEntityType: PropTypes.string,
 }
 
 export { DimensionsList }
diff --git a/src/components/MainSidebar/InputPanel/InputPanel.js b/src/components/MainSidebar/InputPanel/InputPanel.js
index 474b9b689..5039d9b85 100644
--- a/src/components/MainSidebar/InputPanel/InputPanel.js
+++ b/src/components/MainSidebar/InputPanel/InputPanel.js
@@ -1,140 +1,45 @@
-import { useCachedDataQuery } from '@dhis2/analytics'
-import { useDataQuery } from '@dhis2/app-runtime'
+import { useConfig } from '@dhis2/app-runtime'
 import i18n from '@dhis2/d2-i18n'
-import { CenteredContent, CircularLoader, NoticeBox } from '@dhis2/ui'
 import PropTypes from 'prop-types'
-import React, { useEffect } from 'react'
+import React from 'react'
 import { useSelector, useDispatch } from 'react-redux'
-import { tSetUiInput, tSetUiProgram } from '../../../actions/ui.js'
-import {
-    PROGRAM_TYPE_WITHOUT_REGISTRATION,
-    PROGRAM_TYPE_WITH_REGISTRATION,
-} from '../../../modules/programTypes.js'
-import { DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY } from '../../../modules/userSettings.js'
+import { tSetUiInput } from '../../../actions/ui.js'
 import {
     OUTPUT_TYPE_EVENT,
     OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
 } from '../../../modules/visualization.js'
-import { sGetUiInput, sGetUiProgramId } from '../../../reducers/ui.js'
+import { sGetUiInput } from '../../../reducers/ui.js'
 import { ProgramSelect } from '../ProgramDimensionsPanel/ProgramSelect.js'
+import { TypeSelect } from '../ProgramDimensionsPanel/TypeSelect.js'
 import { InputOption } from './InputOption.js'
 import styles from './InputPanel.module.css'
 
-const query = {
-    programs: {
-        resource: 'programs',
-        params: ({ nameProp }) => ({
-            fields: [
-                'id',
-                `${nameProp}~rename(name)`,
-                'enrollmentDateLabel',
-                'incidentDateLabel',
-                'programType',
-                'programStages[id,displayName~rename(name),displayExecutionDateLabel,hideDueDate,displayDueDateLabel,repeatable]',
-                'displayIncidentDate',
-                'displayIncidentDateLabel',
-                'displayEnrollmentDateLabel',
-            ],
-            paging: false,
-            filter: 'access.data.read:eq:true',
-        }),
-    },
-}
-
-const getLabelForInputType = (type) => {
+export const getLabelForInputType = (type) => {
     switch (type) {
         case OUTPUT_TYPE_EVENT:
             return i18n.t('Event')
         case OUTPUT_TYPE_ENROLLMENT:
             return i18n.t('Enrollment')
+        case OUTPUT_TYPE_TRACKED_ENTITY:
+            return i18n.t('Tracked entity')
         default:
             throw new Error('No input type specified')
     }
 }
 
-const InputPanel = ({ visible }) => {
+export const InputPanel = ({ visible }) => {
     const dispatch = useDispatch()
-    const selectedInput = useSelector(sGetUiInput)
-    const selectedProgramId = useSelector(sGetUiProgramId)
-    const { currentUser } = useCachedDataQuery()
-    const { fetching, error, data, refetch, called } = useDataQuery(query, {
-        lazy: true,
-    })
-    const filteredPrograms = data?.programs.programs.filter(
-        ({ programType }) =>
-            !(
-                selectedInput.type === OUTPUT_TYPE_ENROLLMENT &&
-                programType === PROGRAM_TYPE_WITHOUT_REGISTRATION
-            )
-    )
-    const selectedProgram =
-        selectedProgramId &&
-        filteredPrograms?.find(({ id }) => id === selectedProgramId)
-    const programType = selectedProgram?.programType
-    const requiredStageSelection =
-        selectedInput.type === OUTPUT_TYPE_EVENT &&
-        programType === PROGRAM_TYPE_WITH_REGISTRATION
-    const setSelectedProgramId = (programId) => {
-        if (programId !== selectedProgramId) {
-            const program = filteredPrograms?.find(({ id }) => id === programId)
-            const stage =
-                // auto-select first stage if input type is Event
-                selectedInput.type === OUTPUT_TYPE_EVENT &&
-                program?.programStages.length
-                    ? program.programStages[0]
-                    : undefined
-            dispatch(tSetUiProgram({ program, stage }))
-        }
-    }
-
-    useEffect(() => {
-        if (visible && !called) {
-            refetch({
-                nameProp:
-                    currentUser.settings[
-                        DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY
-                    ],
-            })
-        }
-    }, [visible, called, refetch])
+    const { serverVersion } = useConfig()
+    const selectedInput = useSelector(sGetUiInput)?.type
 
     if (!visible) {
         return null
     }
 
     const setSelectedInput = (input) => {
-        if (selectedInput.type !== input.type) {
-            dispatch(tSetUiInput(input))
-        }
-    }
-
-    const renderProgramSelect = () => {
-        if (error && !fetching) {
-            return (
-                <div className={styles.section}>
-                    <NoticeBox error title={i18n.t('Could not load programs')}>
-                        {error?.message ||
-                            i18n.t(
-                                "The programs couldn't be retrieved. Try again or contact your system administrator."
-                            )}
-                    </NoticeBox>
-                </div>
-            )
-        } else if (fetching) {
-            return (
-                <CenteredContent>
-                    <CircularLoader small />
-                </CenteredContent>
-            )
-        } else if (filteredPrograms) {
-            return (
-                <ProgramSelect
-                    programs={filteredPrograms}
-                    selectedProgram={selectedProgram}
-                    setSelectedProgramId={setSelectedProgramId}
-                    requiredStageSelection={requiredStageSelection}
-                />
-            )
+        if (selectedInput !== input) {
+            dispatch(tSetUiInput({ type: input }))
         }
     }
 
@@ -146,11 +51,10 @@ const InputPanel = ({ visible }) => {
                 description={i18n.t(
                     'See individual event data from a Tracker program stage or event program.'
                 )}
-                onClick={() => setSelectedInput({ type: OUTPUT_TYPE_EVENT })}
-                selected={selectedInput.type === OUTPUT_TYPE_EVENT}
+                onClick={() => setSelectedInput(OUTPUT_TYPE_EVENT)}
+                selected={selectedInput === OUTPUT_TYPE_EVENT}
             >
-                {selectedInput.type === OUTPUT_TYPE_EVENT &&
-                    renderProgramSelect()}
+                {selectedInput === OUTPUT_TYPE_EVENT && <ProgramSelect />}
             </InputOption>
             <InputOption
                 dataTest="input-enrollment"
@@ -158,14 +62,28 @@ const InputPanel = ({ visible }) => {
                 description={i18n.t(
                     'See data from multiple program stages in a Tracker program.'
                 )}
-                onClick={() =>
-                    setSelectedInput({ type: OUTPUT_TYPE_ENROLLMENT })
-                }
-                selected={selectedInput.type === OUTPUT_TYPE_ENROLLMENT}
+                onClick={() => setSelectedInput(OUTPUT_TYPE_ENROLLMENT)}
+                selected={selectedInput === OUTPUT_TYPE_ENROLLMENT}
             >
-                {selectedInput.type === OUTPUT_TYPE_ENROLLMENT &&
-                    renderProgramSelect()}
+                {selectedInput === OUTPUT_TYPE_ENROLLMENT && <ProgramSelect />}
             </InputOption>
+            {`${serverVersion.major}.${serverVersion.minor}.${
+                serverVersion.patch || 0
+            }` >= '2.41.0' && (
+                <InputOption
+                    dataTest="input-tracked-entity"
+                    header={getLabelForInputType(OUTPUT_TYPE_TRACKED_ENTITY)}
+                    description={i18n.t(
+                        'See individual tracked entities from one or more Tracker programs.'
+                    )}
+                    onClick={() => setSelectedInput(OUTPUT_TYPE_TRACKED_ENTITY)}
+                    selected={selectedInput === OUTPUT_TYPE_TRACKED_ENTITY}
+                >
+                    {selectedInput === OUTPUT_TYPE_TRACKED_ENTITY && (
+                        <TypeSelect />
+                    )}
+                </InputOption>
+            )}
         </div>
     )
 }
@@ -173,5 +91,3 @@ const InputPanel = ({ visible }) => {
 InputPanel.propTypes = {
     visible: PropTypes.bool.isRequired,
 }
-
-export { InputPanel, getLabelForInputType }
diff --git a/src/components/MainSidebar/MainDimensions.js b/src/components/MainSidebar/MainDimensions.js
index e70e27fc2..e59fc4a30 100644
--- a/src/components/MainSidebar/MainDimensions.js
+++ b/src/components/MainSidebar/MainDimensions.js
@@ -18,7 +18,7 @@ export const MainDimensions = () => {
     return (
         <MainSidebarSection
             header={i18n.t('Global dimensions')}
-            dataTest={'main-dimensions-sidebar'}
+            dataTest="main-dimensions-sidebar"
         >
             {draggableDimensions.map((dimension) => (
                 <span className={styles.span} key={dimension.id}>
diff --git a/src/components/MainSidebar/MainSidebar.js b/src/components/MainSidebar/MainSidebar.js
index bbe789511..b676b6eef 100644
--- a/src/components/MainSidebar/MainSidebar.js
+++ b/src/components/MainSidebar/MainSidebar.js
@@ -12,9 +12,13 @@ import { PROGRAM_TYPE_WITH_REGISTRATION } from '../../modules/programTypes.js'
 import {
     ACCESSORY_PANEL_TAB_INPUT,
     ACCESSORY_PANEL_TAB_PROGRAM,
+    ACCESSORY_PANEL_TAB_TRACKED_ENTITY,
     ACCESSORY_PANEL_TAB_YOUR,
 } from '../../modules/ui.js'
-import { OUTPUT_TYPE_EVENT } from '../../modules/visualization.js'
+import {
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../../modules/visualization.js'
 import { sGetMetadataById } from '../../reducers/metadata.js'
 import {
     sGetUiInputType,
@@ -23,6 +27,7 @@ import {
     sGetUiSidebarHidden,
     sGetUiProgramStageId,
     sGetUiAccessoryPanelActiveTab,
+    sGetUiEntityTypeId,
 } from '../../reducers/ui.js'
 import { InputPanel, getLabelForInputType } from './InputPanel/index.js'
 import { MainDimensions } from './MainDimensions.js'
@@ -33,6 +38,8 @@ import {
     SelectedDimensionsProvider,
     useSelectedDimensions,
 } from './SelectedDimensionsContext.js'
+import { TrackedEntityDimensionsMenuItem } from './TrackedEntityDimensionsMenuItem.js'
+import { TrackedEntityDimensionsPanel } from './TrackedEntityDimensionsPanel/index.js'
 import { YourDimensionsMenuItem } from './YourDimensionsMenuItem.js'
 import { YourDimensionsPanel } from './YourDimensionsPanel/index.js'
 
@@ -43,19 +50,31 @@ const MainSidebar = () => {
     const selectedInputType = useSelector(sGetUiInputType)
     const selectedProgramId = useSelector(sGetUiProgramId)
     const selectedStageId = useSelector(sGetUiProgramStageId)
+    const selectedEntityTypeId = useSelector(sGetUiEntityTypeId)
     const program = useSelector((state) =>
         sGetMetadataById(state, selectedProgramId)
     )
     const stage = useSelector((state) =>
         sGetMetadataById(state, selectedStageId)
     )
-    const subtitle =
-        selectedInputType === OUTPUT_TYPE_EVENT &&
-        program?.programType === PROGRAM_TYPE_WITH_REGISTRATION &&
-        program?.name &&
-        stage?.name
-            ? `${program.name} - ${stage.name}`
-            : program?.name
+    const entityType = useSelector((state) =>
+        sGetMetadataById(state, selectedEntityTypeId)
+    )
+    const getSubtitle = () => {
+        if (
+            selectedInputType === OUTPUT_TYPE_EVENT &&
+            program?.programType === PROGRAM_TYPE_WITH_REGISTRATION &&
+            program?.name &&
+            stage?.name
+        ) {
+            return `${program.name} - ${stage.name}`
+        } else if (selectedInputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+            return entityType?.name
+        } else {
+            return program?.name
+        }
+    }
+
     const isHidden = useSelector(sGetUiSidebarHidden)
     const setOpen = (newOpen) => dispatch(acSetUiAccessoryPanelOpen(newOpen))
     const setSelectedTabId = (id) =>
@@ -79,7 +98,7 @@ const MainSidebar = () => {
             onClick={() => onClick(ACCESSORY_PANEL_TAB_PROGRAM)}
             selected={open && selectedTabId === ACCESSORY_PANEL_TAB_PROGRAM}
             count={counts.program}
-            disabled={!selectedProgramId}
+            disabled={!(selectedProgramId || selectedEntityTypeId)}
             dataTest="program-dimensions-button"
         />
     )
@@ -97,11 +116,25 @@ const MainSidebar = () => {
                     selected={
                         open && selectedTabId === ACCESSORY_PANEL_TAB_INPUT
                     }
-                    subtitle={subtitle}
+                    subtitle={getSubtitle()}
+                    dataTest="input-panel-button"
                 />
-                {!selectedProgramId ? (
+                {entityType?.name && (
+                    <TrackedEntityDimensionsMenuItem
+                        selected={
+                            open &&
+                            selectedTabId === ACCESSORY_PANEL_TAB_TRACKED_ENTITY
+                        }
+                        count={counts.trackedEntity}
+                        onClick={() =>
+                            onClick(ACCESSORY_PANEL_TAB_TRACKED_ENTITY)
+                        }
+                        name={entityType.name}
+                    />
+                )}
+                {!(selectedProgramId || selectedEntityTypeId) ? (
                     <Tooltip
-                        dataTest={'no-input-tooltip'}
+                        dataTest="no-input-tooltip"
                         content={i18n.t('Choose an input first')}
                         closeDelay={0}
                         placement="bottom"
@@ -119,7 +152,6 @@ const MainSidebar = () => {
                 ) : (
                     programDimensionsItem
                 )}
-
                 <YourDimensionsMenuItem
                     selected={
                         open && selectedTabId === ACCESSORY_PANEL_TAB_YOUR
@@ -144,6 +176,11 @@ const MainSidebar = () => {
                     <ProgramDimensionsPanel
                         visible={selectedTabId === ACCESSORY_PANEL_TAB_PROGRAM}
                     />
+                    <TrackedEntityDimensionsPanel
+                        visible={
+                            selectedTabId === ACCESSORY_PANEL_TAB_TRACKED_ENTITY
+                        }
+                    />
                     <YourDimensionsPanel
                         visible={selectedTabId === ACCESSORY_PANEL_TAB_YOUR}
                     />
diff --git a/src/components/MainSidebar/MenuItem/MenuItem.js b/src/components/MainSidebar/MenuItem/MenuItem.js
index 1b950a7e5..8f3a84200 100644
--- a/src/components/MainSidebar/MenuItem/MenuItem.js
+++ b/src/components/MainSidebar/MenuItem/MenuItem.js
@@ -24,9 +24,16 @@ const MenuItem = ({
         data-test={dataTest}
     >
         <div className={styles.icon}>{icon}</div>
-        <div className={styles.label}>
-            {label}
-            {subtitle && <span className={styles.subtitle}>{subtitle}</span>}
+        <div className={styles.labelWrapper}>
+            <span className={styles.label}>{label}</span>
+            {subtitle && (
+                <span
+                    className={styles.subtitle}
+                    data-test={`${dataTest}-subtitle`}
+                >
+                    {subtitle}
+                </span>
+            )}
         </div>
         {typeof count === 'number' && (
             <div
diff --git a/src/components/MainSidebar/MenuItem/MenuItem.module.css b/src/components/MainSidebar/MenuItem/MenuItem.module.css
index a1cf7af7f..d9924d80c 100644
--- a/src/components/MainSidebar/MenuItem/MenuItem.module.css
+++ b/src/components/MainSidebar/MenuItem/MenuItem.module.css
@@ -46,12 +46,17 @@
     margin-right: 2px;
     color: var(--colors-grey700);
 }
-.label {
+.labelWrapper {
     flex-grow: 1;
     display: flex;
     flex-direction: column;
     font-size: 14px;
     line-height: 16px;
+    overflow: hidden;
+}
+.label {
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
 .count {
     flex-grow: 0;
@@ -78,4 +83,6 @@
     font-size: 13px;
     color: var(--colors-grey700);
     margin-top: var(--spacers-dp4);
+    overflow: hidden;
+    text-overflow: ellipsis;
 }
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDataDimensionsList.js b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDataDimensionsList.js
index 95135feef..53d7df6f5 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDataDimensionsList.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDataDimensionsList.js
@@ -5,6 +5,7 @@ import { useProgramDataDimensions } from './useProgramDataDimensions.js'
 
 const ProgramDataDimensionsList = ({
     inputType,
+    trackedEntityTypeId,
     program,
     stageId,
     searchTerm,
@@ -13,6 +14,7 @@ const ProgramDataDimensionsList = ({
     const { dimensions, loading, fetching, error, setIsListEndVisible } =
         useProgramDataDimensions({
             inputType,
+            trackedEntityTypeId,
             program,
             stageId,
             searchTerm,
@@ -44,6 +46,7 @@ ProgramDataDimensionsList.propTypes = {
     dimensionType: PropTypes.string,
     searchTerm: PropTypes.string,
     stageId: PropTypes.string,
+    trackedEntityTypeId: PropTypes.string,
 }
 
 export { ProgramDataDimensionsList }
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensions.js b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensions.js
index 90dda453b..88591edb5 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensions.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensions.js
@@ -22,7 +22,7 @@ export const ProgramDimensions = () => {
     return (
         <MainSidebarSection
             header={i18n.t('Program dimensions')}
-            dataTest={'program-dimensions'}
+            dataTest="program-dimensions"
         >
             {draggableDimensions.map((dimension) => (
                 <span key={dimension.id} className={styles.span}>
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsFilter.js b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsFilter.js
index b1a465136..9d030b6ed 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsFilter.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsFilter.js
@@ -12,8 +12,10 @@ import cx from 'classnames'
 import PropTypes from 'prop-types'
 import React from 'react'
 import { useSelector } from 'react-redux'
-import { PROGRAM_TYPE_WITH_REGISTRATION } from '../../../modules/programTypes.js'
-import { OUTPUT_TYPE_ENROLLMENT } from '../../../modules/visualization.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../../../modules/visualization.js'
 import { sGetUiInputType } from '../../../reducers/ui.js'
 import { DimensionIcon } from '../DimensionItem/DimensionIcon.js'
 import styles from './ProgramDimensionsFilter.module.css'
@@ -46,6 +48,7 @@ const ProgramDimensionsFilter = ({
     setDimensionType,
     stageFilter,
     setStageFilter,
+    showProgramAttribute,
 }) => (
     <div className={styles.container}>
         <div className={styles.header}>{i18n.t('Program data dimensions')}</div>
@@ -53,7 +56,7 @@ const ProgramDimensionsFilter = ({
             value={searchTerm}
             onChange={({ value }) => setSearchTerm(value)}
             dense
-            type={'search'}
+            type="search"
             placeholder={i18n.t('Search data dimensions')}
         />
         <SingleSelect
@@ -76,7 +79,7 @@ const ProgramDimensionsFilter = ({
                     />
                 }
             />
-            {program.programType === PROGRAM_TYPE_WITH_REGISTRATION && (
+            {showProgramAttribute && (
                 <SingleSelectOption
                     label={i18n.t('Program attribute')}
                     value={DIMENSION_TYPE_PROGRAM_ATTRIBUTE}
@@ -87,15 +90,17 @@ const ProgramDimensionsFilter = ({
                     }
                 />
             )}
-            <SingleSelectOption
-                label={i18n.t('Program indicator')}
-                value={DIMENSION_TYPE_PROGRAM_INDICATOR}
-                icon={
-                    <DimensionIcon
-                        dimensionType={DIMENSION_TYPE_PROGRAM_INDICATOR}
-                    />
-                }
-            />
+            {useSelector(sGetUiInputType) !== OUTPUT_TYPE_TRACKED_ENTITY && (
+                <SingleSelectOption
+                    label={i18n.t('Program indicator')}
+                    value={DIMENSION_TYPE_PROGRAM_INDICATOR}
+                    icon={
+                        <DimensionIcon
+                            dimensionType={DIMENSION_TYPE_PROGRAM_INDICATOR}
+                        />
+                    }
+                />
+            )}
             <SingleSelectOption
                 label={i18n.t('Category')}
                 value={DIMENSION_TYPE_CATEGORY}
@@ -111,10 +116,16 @@ const ProgramDimensionsFilter = ({
                 }
             />
         </SingleSelect>
-        {useSelector(sGetUiInputType) === OUTPUT_TYPE_ENROLLMENT &&
-            dimensionType === DIMENSION_TYPE_DATA_ELEMENT && (
+        {[OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_TRACKED_ENTITY].includes(
+            useSelector(sGetUiInputType)
+        ) &&
+            dimensionType === DIMENSION_TYPE_DATA_ELEMENT &&
+            (!stageFilter ||
+                program?.programStages.some(
+                    (stage) => stage.id === stageFilter
+                )) && (
                 <StageFilter
-                    stages={program.programStages}
+                    stages={program?.programStages}
                     selected={stageFilter}
                     setSelected={setStageFilter}
                 />
@@ -129,6 +140,7 @@ ProgramDimensionsFilter.propTypes = {
     setDimensionType: PropTypes.func,
     setSearchTerm: PropTypes.func,
     setStageFilter: PropTypes.func,
+    showProgramAttribute: PropTypes.bool,
     stageFilter: PropTypes.string,
 }
 
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsPanel.js b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsPanel.js
index d18c801ed..f4b6bb393 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsPanel.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramDimensionsPanel.js
@@ -3,16 +3,20 @@ import {
     DIMENSION_TYPE_DATA_ELEMENT,
 } from '@dhis2/analytics'
 import i18n from '@dhis2/d2-i18n'
+import cx from 'classnames'
 import PropTypes from 'prop-types'
 import React, { useEffect, useState } from 'react'
 import { useSelector } from 'react-redux'
+import { PROGRAM_TYPE_WITH_REGISTRATION } from '../../../modules/programTypes.js'
 import { useDebounce } from '../../../modules/utils.js'
 import {
     OUTPUT_TYPE_EVENT,
     OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
 } from '../../../modules/visualization.js'
 import { sGetMetadataById } from '../../../reducers/metadata.js'
 import {
+    sGetUiEntityTypeId,
     sGetUiInputType,
     sGetUiProgramId,
     sGetUiProgramStageId,
@@ -21,10 +25,12 @@ import { ProgramDataDimensionsList } from './ProgramDataDimensionsList.js'
 import { ProgramDimensions } from './ProgramDimensions.js'
 import { ProgramDimensionsFilter } from './ProgramDimensionsFilter.js'
 import styles from './ProgramDimensionsPanel.module.css'
+import { ProgramSelect } from './ProgramSelect.js'
 
 const ProgramDimensionsPanel = ({ visible }) => {
     const inputType = useSelector(sGetUiInputType)
     const selectedProgramId = useSelector(sGetUiProgramId)
+    const selectedTrackedEntityTypeId = useSelector(sGetUiEntityTypeId)
     const selectedProgram = useSelector((state) =>
         sGetMetadataById(state, selectedProgramId)
     )
@@ -34,10 +40,15 @@ const ProgramDimensionsPanel = ({ visible }) => {
     const [stageFilter, setStageFilter] = useState()
     const [dimensionType, setDimensionType] = useState(DIMENSION_TYPE_ALL)
     const debouncedSearchTerm = useDebounce(searchTerm)
-    const isProgramSelectionComplete =
-        inputType === OUTPUT_TYPE_EVENT
-            ? selectedProgram && selectedStageId
-            : !!selectedProgram
+    const isProgramSelectionComplete = () => {
+        if (inputType === OUTPUT_TYPE_EVENT) {
+            return selectedProgram && selectedStageId
+        } else if (inputType === OUTPUT_TYPE_ENROLLMENT) {
+            return !!selectedProgram
+        } else if (inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+            return !!selectedTrackedEntityTypeId
+        }
+    }
 
     useEffect(() => {
         setSearchTerm('')
@@ -49,49 +60,117 @@ const ProgramDimensionsPanel = ({ visible }) => {
         return null
     }
 
-    return (
-        <div className={styles.container}>
-            {isProgramSelectionComplete ? (
-                <>
-                    <div>
-                        <ProgramDimensions />
-                    </div>
-                    <div className={styles.section}>
-                        <ProgramDimensionsFilter
+    if ([OUTPUT_TYPE_EVENT, OUTPUT_TYPE_ENROLLMENT].includes(inputType)) {
+        return (
+            <div className={styles.container}>
+                {isProgramSelectionComplete() ? (
+                    <>
+                        <div>
+                            <ProgramDimensions />
+                        </div>
+                        <div className={styles.section}>
+                            <ProgramDimensionsFilter
+                                program={selectedProgram}
+                                searchTerm={searchTerm}
+                                setSearchTerm={setSearchTerm}
+                                dimensionType={dimensionType}
+                                setDimensionType={setDimensionType}
+                                stageFilter={stageFilter}
+                                setStageFilter={setStageFilter}
+                                showProgramAttribute={
+                                    selectedProgram.programType ===
+                                    PROGRAM_TYPE_WITH_REGISTRATION
+                                }
+                            />
+                        </div>
+
+                        <ProgramDataDimensionsList
+                            inputType={inputType}
                             program={selectedProgram}
-                            searchTerm={searchTerm}
-                            setSearchTerm={setSearchTerm}
                             dimensionType={dimensionType}
-                            setDimensionType={setDimensionType}
-                            stageFilter={stageFilter}
-                            setStageFilter={setStageFilter}
+                            searchTerm={debouncedSearchTerm}
+                            stageId={
+                                [
+                                    OUTPUT_TYPE_ENROLLMENT,
+                                    OUTPUT_TYPE_TRACKED_ENTITY,
+                                ].includes(inputType) ===
+                                    OUTPUT_TYPE_ENROLLMENT &&
+                                dimensionType === DIMENSION_TYPE_DATA_ELEMENT
+                                    ? stageFilter
+                                    : inputType === OUTPUT_TYPE_EVENT
+                                    ? selectedStageId
+                                    : undefined
+                            }
                         />
+                    </>
+                ) : (
+                    <div className={styles.helptext}>
+                        {i18n.t(
+                            'Choose an input to get started adding program dimensions.'
+                        )}
                     </div>
+                )}
+            </div>
+        )
+    } else if (inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        return (
+            <div className={styles.container}>
+                {isProgramSelectionComplete() ? (
+                    <>
+                        <div className={cx(styles.section, styles.bordered)}>
+                            <ProgramSelect prefix={i18n.t('Program')} />
+                        </div>
+                        {selectedProgram && (
+                            <>
+                                <div>
+                                    <ProgramDimensions />
+                                </div>
+                                <div className={styles.section}>
+                                    <ProgramDimensionsFilter
+                                        program={selectedProgram}
+                                        searchTerm={searchTerm}
+                                        setSearchTerm={setSearchTerm}
+                                        dimensionType={dimensionType}
+                                        setDimensionType={setDimensionType}
+                                        stageFilter={stageFilter}
+                                        setStageFilter={setStageFilter}
+                                    />
+                                </div>
 
-                    <ProgramDataDimensionsList
-                        inputType={inputType}
-                        program={selectedProgram}
-                        dimensionType={dimensionType}
-                        searchTerm={debouncedSearchTerm}
-                        stageId={
-                            inputType === OUTPUT_TYPE_ENROLLMENT &&
-                            dimensionType === DIMENSION_TYPE_DATA_ELEMENT
-                                ? stageFilter
-                                : inputType === OUTPUT_TYPE_EVENT
-                                ? selectedStageId
-                                : undefined
-                        }
-                    />
-                </>
-            ) : (
-                <div className={styles.helptext}>
-                    {i18n.t(
-                        'Choose an input to get started adding program dimensions.'
-                    )}
-                </div>
-            )}
-        </div>
-    )
+                                <ProgramDataDimensionsList
+                                    inputType={inputType}
+                                    program={selectedProgram}
+                                    dimensionType={dimensionType}
+                                    searchTerm={debouncedSearchTerm}
+                                    stageId={
+                                        [
+                                            OUTPUT_TYPE_ENROLLMENT,
+                                            OUTPUT_TYPE_TRACKED_ENTITY,
+                                        ].includes(inputType) &&
+                                        dimensionType ===
+                                            DIMENSION_TYPE_DATA_ELEMENT
+                                            ? stageFilter
+                                            : inputType === OUTPUT_TYPE_EVENT
+                                            ? selectedStageId
+                                            : undefined
+                                    }
+                                    trackedEntityTypeId={
+                                        selectedTrackedEntityTypeId
+                                    }
+                                />
+                            </>
+                        )}
+                    </>
+                ) : (
+                    <div className={styles.helptext}>
+                        {i18n.t(
+                            'Choose an input to get started adding program dimensions.'
+                        )}
+                    </div>
+                )}
+            </div>
+        )
+    }
 }
 
 ProgramDimensionsPanel.propTypes = {
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramSelect.js b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramSelect.js
index ce76973b3..debb95c2a 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/ProgramSelect.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/ProgramSelect.js
@@ -1,41 +1,176 @@
+import { useCachedDataQuery } from '@dhis2/analytics'
+import { useDataQuery } from '@dhis2/app-runtime'
 import i18n from '@dhis2/d2-i18n'
-import { SingleSelect, SingleSelectOption } from '@dhis2/ui'
+import { NoticeBox, SingleSelect } from '@dhis2/ui'
 import PropTypes from 'prop-types'
-import React from 'react'
+import React, { useEffect, useState } from 'react'
+import { useDispatch, useSelector } from 'react-redux'
+import { tSetUiProgram } from '../../../actions/ui.js'
+import { extractDimensionIdParts } from '../../../modules/dimensionId.js'
+import { PROGRAM_TYPE_WITH_REGISTRATION } from '../../../modules/programTypes.js'
+import { DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY } from '../../../modules/userSettings.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../../../modules/visualization.js'
+import { sGetMetadataById } from '../../../reducers/metadata.js'
+import {
+    sGetDimensionIdsFromLayout,
+    sGetUiEntityTypeId,
+    sGetUiInputType,
+    sGetUiProgramId,
+} from '../../../reducers/ui.js'
 import styles from './ProgramSelect.module.css'
+import { SingleSelectOptionWithSuffix } from './SingleSelectOptionWithSuffix.js'
 import { StageSelect } from './StageSelect.js'
 
-const ProgramSelect = ({
-    programs,
-    setSelectedProgramId,
-    requiredStageSelection,
-    selectedProgram,
-}) => {
+const query = {
+    programs: {
+        resource: 'programs',
+        params: ({ nameProp, selectedEntityTypeId, inputType }) => ({
+            fields: [
+                'id',
+                `${nameProp}~rename(name)`,
+                'enrollmentDateLabel',
+                'incidentDateLabel',
+                'programType',
+                'programStages[id,displayName~rename(name),displayExecutionDateLabel,hideDueDate,displayDueDateLabel,repeatable]',
+                'displayIncidentDate',
+                'displayIncidentDateLabel',
+                'displayEnrollmentDateLabel',
+            ],
+            paging: false,
+            filter: [
+                'access.data.read:eq:true',
+                ...(selectedEntityTypeId
+                    ? [`trackedEntityType.id:eq:${selectedEntityTypeId}`]
+                    : []),
+                ...(inputType === OUTPUT_TYPE_ENROLLMENT
+                    ? [`programType:eq:${PROGRAM_TYPE_WITH_REGISTRATION}`]
+                    : []),
+            ],
+        }),
+    },
+}
+
+const ProgramSelect = ({ prefix }) => {
+    const { currentUser } = useCachedDataQuery()
+    const dispatch = useDispatch()
+    const selectedEntityTypeId = useSelector(sGetUiEntityTypeId)
+    const selectedProgramId = useSelector(sGetUiProgramId)
+    const selectedProgram = useSelector((state) =>
+        sGetMetadataById(state, selectedProgramId)
+    )
+    const allDimensionIds = useSelector(sGetDimensionIdsFromLayout)
+    const inputType = useSelector(sGetUiInputType)
+    const { fetching, error, data, refetch } = useDataQuery(query, {
+        lazy: true,
+    })
+    const [programDimensionsMap, setProgramDimensionsMap] = useState({})
+
+    const programs = data?.programs.programs
+    const programType = selectedProgram?.programType
+    const requiredStageSelection =
+        inputType === OUTPUT_TYPE_EVENT &&
+        programType === PROGRAM_TYPE_WITH_REGISTRATION
     const showStageSelect = selectedProgram && requiredStageSelection
 
+    const setSelectedProgramId = (programId) => {
+        if (programId !== selectedProgramId) {
+            const program = programs?.find(({ id }) => id === programId)
+            const stage =
+                // auto-select first stage if input type is Event
+                inputType === OUTPUT_TYPE_EVENT && program?.programStages.length
+                    ? program.programStages[0]
+                    : undefined
+            dispatch(tSetUiProgram({ program, stage }))
+        }
+    }
+
+    useEffect(() => {
+        if (inputType === OUTPUT_TYPE_TRACKED_ENTITY && selectedEntityTypeId) {
+            const map = {}
+            allDimensionIds.forEach((id) => {
+                const { programId } = extractDimensionIdParts(id, inputType)
+                if (programId) {
+                    map[programId] = map[programId] ? map[programId] + 1 : 1
+                }
+            })
+            setProgramDimensionsMap(map)
+        }
+    }, [selectedEntityTypeId, allDimensionIds, inputType])
+
+    useEffect(() => {
+        refetch({
+            nameProp:
+                currentUser.settings[
+                    DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY
+                ],
+            selectedEntityTypeId,
+            inputType,
+        })
+    }, [refetch, selectedEntityTypeId, currentUser, inputType])
+
+    if (error && !fetching) {
+        return (
+            <div className={styles.section}>
+                <NoticeBox error title={i18n.t('Could not load programs')}>
+                    {error?.message ||
+                        i18n.t(
+                            "The programs couldn't be retrieved. Try again or contact your system administrator."
+                        )}
+                </NoticeBox>
+            </div>
+        )
+    }
     return (
         <div className={styles.rows}>
             <div className={styles.columns}>
                 <div className={styles.stretch}>
                     <SingleSelect
                         dense
-                        selected={selectedProgram?.id}
+                        selected={selectedProgram?.id || ''}
                         onChange={({ selected }) =>
                             setSelectedProgramId(selected)
                         }
                         placeholder={i18n.t('Choose a program')}
                         maxHeight="max(60vh, 460px)"
-                        dataTest={'program-select'}
+                        dataTest="program-dimensions-program-select"
                         filterable
                         noMatchText={i18n.t('No programs found')}
+                        prefix={selectedProgram?.id ? prefix : ''}
+                        empty={i18n.t('No programs found')}
+                        loading={fetching}
                     >
-                        {programs.map(({ id, name }) => (
-                            <SingleSelectOption
-                                key={id}
-                                label={name}
-                                value={id}
+                        {(fetching || !programs) && selectedProgram?.id && (
+                            <SingleSelectOptionWithSuffix
+                                key={selectedProgram?.id}
+                                label={selectedProgram?.name}
+                                suffix={
+                                    (selectedEntityTypeId &&
+                                        selectedProgram?.id &&
+                                        programDimensionsMap[
+                                            selectedProgram.id
+                                        ]) ||
+                                    null
+                                }
+                                value={selectedProgram?.id}
                             />
-                        ))}
+                        )}
+                        {!fetching &&
+                            programs?.map(({ id, name }) => (
+                                <SingleSelectOptionWithSuffix
+                                    key={id}
+                                    label={name}
+                                    value={id}
+                                    suffix={
+                                        (selectedEntityTypeId &&
+                                            programDimensionsMap[id]) ||
+                                        null
+                                    }
+                                />
+                            ))}
                     </SingleSelect>
                 </div>
             </div>
@@ -47,10 +182,7 @@ const ProgramSelect = ({
 }
 
 ProgramSelect.propTypes = {
-    programs: PropTypes.array.isRequired,
-    setSelectedProgramId: PropTypes.func.isRequired,
-    requiredStageSelection: PropTypes.bool,
-    selectedProgram: PropTypes.object,
+    prefix: PropTypes.string,
 }
 
 export { ProgramSelect }
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.js b/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.js
new file mode 100644
index 000000000..9acabcc7a
--- /dev/null
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.js
@@ -0,0 +1,39 @@
+import { Tag } from '@dhis2/ui'
+import cx from 'classnames'
+import PropTypes from 'prop-types'
+import React from 'react'
+import styles from './SingleSelectOptionWithSuffix.module.css'
+
+export const SingleSelectOptionWithSuffix = ({
+    label,
+    active,
+    disabled,
+    onClick,
+    value,
+    dataTest,
+    suffix,
+}) => (
+    <div
+        className={cx(styles.option, {
+            [styles.disabled]: disabled,
+            [styles.active]: active,
+        })}
+        onClick={(e) => onClick({}, e)}
+        data-value={value}
+        data-label={label}
+        data-test={dataTest}
+    >
+        {label}
+        {suffix && <Tag className={styles.tag}>{suffix.toString()}</Tag>}
+    </div>
+)
+
+SingleSelectOptionWithSuffix.propTypes = {
+    label: PropTypes.string.isRequired,
+    value: PropTypes.string.isRequired,
+    active: PropTypes.bool,
+    dataTest: PropTypes.string,
+    disabled: PropTypes.bool,
+    suffix: PropTypes.number,
+    onClick: PropTypes.func,
+}
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.module.css b/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.module.css
new file mode 100644
index 000000000..c7f9bda75
--- /dev/null
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/SingleSelectOptionWithSuffix.module.css
@@ -0,0 +1,36 @@
+.option {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    cursor: pointer;
+    font-size: 14px;
+    text-decoration: none;
+    color: var(--colors-grey900);
+    padding-block: var(--spacers-dp8);
+    padding-inline: var(--spacers-dp12);
+}
+
+.option:hover {
+    background-color: var(--colors-grey200);
+}
+
+.option:active,
+.option.active {
+    background-color: var(--colors-teal700);
+    color: var(--colors-white);
+    cursor: auto;
+}
+
+.option.disabled {
+    color: var(--colors-grey500);
+    cursor: not-allowed;
+    user-select: none;
+}
+
+.option.disabled:hover {
+    background-color: initial;
+}
+
+.tag {
+    margin-left: var(--spacers-dp8);
+}
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/StageFilter.js b/src/components/MainSidebar/ProgramDimensionsPanel/StageFilter.js
index 42bafbd5f..55e53d7b4 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/StageFilter.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/StageFilter.js
@@ -20,7 +20,7 @@ const StageFilter = ({ stages, selected, setSelected }) => {
             dense
             selected={selected || STAGE_ALL}
             onChange={onChange}
-            dataTest={'stage-select'}
+            dataTest="stage-select"
         >
             <SingleSelectOption label={i18n.t('All')} value={STAGE_ALL} />
             {stages.map(({ id, name }) => (
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/StageSelect.js b/src/components/MainSidebar/ProgramDimensionsPanel/StageSelect.js
index 4f79632fd..e667d7ad1 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/StageSelect.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/StageSelect.js
@@ -32,7 +32,7 @@ const StageSelect = ({ stages }) => {
                         dense
                         selected={selectedStageId}
                         onChange={onChange}
-                        dataTest={'stage-select'}
+                        dataTest="stage-select"
                         filterable
                         noMatchText={i18n.t('No stages found')}
                     >
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/TypeSelect.js b/src/components/MainSidebar/ProgramDimensionsPanel/TypeSelect.js
new file mode 100644
index 000000000..532916465
--- /dev/null
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/TypeSelect.js
@@ -0,0 +1,100 @@
+import { useDataQuery } from '@dhis2/app-runtime'
+import i18n from '@dhis2/d2-i18n'
+import { NoticeBox, SingleSelect, SingleSelectOption } from '@dhis2/ui'
+import React, { useEffect } from 'react'
+import { useDispatch, useSelector } from 'react-redux'
+import { tSetUiEntityType } from '../../../actions/ui.js'
+import { sGetMetadataById } from '../../../reducers/metadata.js'
+import { sGetUiEntityTypeId } from '../../../reducers/ui.js'
+import styles from './ProgramSelect.module.css'
+
+const query = {
+    programs: {
+        resource: 'trackedEntityTypes',
+        params: () => ({
+            fields: ['id', 'displayName~rename(name)'],
+            paging: false,
+            filter: 'access.data.read:eq:true',
+        }),
+    },
+}
+
+const TypeSelect = () => {
+    const dispatch = useDispatch()
+    const selectedTypeId = useSelector(sGetUiEntityTypeId)
+    const { fetching, error, data, refetch, called } = useDataQuery(query, {
+        lazy: true,
+    })
+
+    const types = data?.programs.trackedEntityTypes
+
+    const selectedType = useSelector((state) =>
+        sGetMetadataById(state, selectedTypeId)
+    )
+
+    const setSelectedTypeId = (typeId) => {
+        if (typeId !== selectedTypeId) {
+            const type = types?.find(({ id }) => id === typeId)
+            dispatch(tSetUiEntityType({ type }))
+        }
+    }
+
+    useEffect(() => {
+        if (!called) {
+            refetch()
+        }
+    }, [called, refetch])
+
+    if (error && !fetching) {
+        return (
+            <div className={styles.section}>
+                <NoticeBox error title={i18n.t('Could not load types')}>
+                    {error?.message ||
+                        i18n.t(
+                            "The types couldn't be retrieved. Try again or contact your system administrator."
+                        )}
+                </NoticeBox>
+            </div>
+        )
+    }
+
+    return (
+        <div className={styles.rows}>
+            <div className={styles.columns}>
+                <div className={styles.stretch}>
+                    <SingleSelect
+                        dense
+                        selected={selectedType?.id || ''}
+                        onChange={({ selected }) => setSelectedTypeId(selected)}
+                        placeholder={i18n.t('Choose a type')}
+                        maxHeight="max(60vh, 460px)"
+                        dataTest="type-select"
+                        filterable
+                        noMatchText={i18n.t('No types found')}
+                        loading={fetching}
+                    >
+                        {(fetching || !types) && selectedType?.id && (
+                            <SingleSelectOption
+                                key={selectedType?.id}
+                                label={selectedType?.name}
+                                value={selectedType?.id}
+                            />
+                        )}
+                        {!fetching &&
+                            types?.map(({ id, name }) => (
+                                <SingleSelectOption
+                                    key={id}
+                                    label={name}
+                                    value={id}
+                                />
+                            ))}
+                    </SingleSelect>
+                </div>
+            </div>
+        </div>
+    )
+}
+
+TypeSelect.propTypes = {}
+
+export { TypeSelect }
diff --git a/src/components/MainSidebar/ProgramDimensionsPanel/useProgramDataDimensions.js b/src/components/MainSidebar/ProgramDimensionsPanel/useProgramDataDimensions.js
index fe451c81c..2713df69d 100644
--- a/src/components/MainSidebar/ProgramDimensionsPanel/useProgramDataDimensions.js
+++ b/src/components/MainSidebar/ProgramDimensionsPanel/useProgramDataDimensions.js
@@ -5,11 +5,12 @@ import {
 } from '@dhis2/analytics'
 import { useDataEngine } from '@dhis2/app-runtime'
 import { useEffect, useReducer, useCallback, useRef, useMemo } from 'react'
+import { extractDimensionIdParts } from '../../../modules/dimensionId.js'
 import { DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY } from '../../../modules/userSettings.js'
-import { extractDimensionIdParts } from '../../../modules/utils.js'
 import {
     OUTPUT_TYPE_EVENT,
     OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
 } from '../../../modules/visualization.js'
 import { DIMENSION_LIST_FIELDS } from '../DimensionsList/index.js'
 
@@ -68,19 +69,22 @@ const reducer = (state, action) => {
     }
 }
 
+const resourceMap = {
+    [OUTPUT_TYPE_TRACKED_ENTITY]: 'analytics/trackedEntities/query/dimensions',
+    [OUTPUT_TYPE_ENROLLMENT]: 'analytics/enrollments/query/dimensions',
+    [OUTPUT_TYPE_EVENT]: 'analytics/events/query/dimensions',
+}
+
 const createDimensionsQuery = ({
     inputType,
     page,
+    trackedEntityTypeId,
     programId,
     stageId,
     searchTerm,
     dimensionType,
     nameProp,
 }) => {
-    const resource =
-        inputType === OUTPUT_TYPE_EVENT
-            ? 'analytics/events/query/dimensions'
-            : 'analytics/enrollments/query/dimensions'
     const params = {
         pageSize: 50,
         page,
@@ -89,8 +93,16 @@ const createDimensionsQuery = ({
         order: `${nameProp}:asc`,
     }
 
-    if (programId && inputType === OUTPUT_TYPE_ENROLLMENT) {
-        params.programId = programId
+    if (trackedEntityTypeId && inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        params.trackedEntityType = trackedEntityTypeId
+    }
+
+    if (programId) {
+        if (inputType === OUTPUT_TYPE_ENROLLMENT) {
+            params.programId = programId
+        } else if (inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+            params.program = programId
+        }
     }
 
     if (stageId && inputType === OUTPUT_TYPE_EVENT) {
@@ -107,6 +119,22 @@ const createDimensionsQuery = ({
         params.filter.push(`id:startsWith:${stageId}`)
     }
 
+    if (
+        programId &&
+        stageId &&
+        inputType === OUTPUT_TYPE_TRACKED_ENTITY &&
+        dimensionType === DIMENSION_TYPE_DATA_ELEMENT
+    ) {
+        // This works because data element IDs have the following notation:
+        // `${programId}.${programStageId}.${dataElementId}`
+        params.filter.push(`id:startsWith:${programId}.${stageId}`)
+    }
+
+    if (inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        params.filter.push('dimensionType:ne:PROGRAM_ATTRIBUTE')
+        params.filter.push('dimensionType:ne:PROGRAM_INDICATOR')
+    }
+
     /*
      * TODO: currently no matches on shortname are captured
      * if this is required we would need the backend add support for this, because
@@ -124,7 +152,7 @@ const createDimensionsQuery = ({
     }
 
     return {
-        resource,
+        resource: resourceMap[inputType],
         params,
     }
 }
@@ -140,7 +168,9 @@ const transformResponseData = ({
     const pager = data.dimensions.pager
     let newDuplicateFound = false
 
-    if (inputType === OUTPUT_TYPE_ENROLLMENT) {
+    if (
+        [OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_TRACKED_ENTITY].includes(inputType)
+    ) {
         data.dimensions.dimensions.forEach((dimension) => {
             const { dimensionId } = extractDimensionIdParts(dimension.id)
             if (
@@ -190,6 +220,7 @@ const transformResponseData = ({
 
 const useProgramDataDimensions = ({
     inputType,
+    trackedEntityTypeId,
     program,
     stageId,
     searchTerm,
@@ -251,6 +282,7 @@ const useProgramDataDimensions = ({
                     dimensions: createDimensionsQuery({
                         inputType,
                         page,
+                        trackedEntityTypeId,
                         programId,
                         stageId,
                         searchTerm,
@@ -280,6 +312,7 @@ const useProgramDataDimensions = ({
             programStageNames,
             inputType,
             nextPage,
+            trackedEntityTypeId,
             programId,
             stageId,
             searchTerm,
@@ -290,7 +323,15 @@ const useProgramDataDimensions = ({
 
     useEffect(() => {
         fetchDimensions(true)
-    }, [inputType, programId, stageId, searchTerm, dimensionType, nameProp])
+    }, [
+        inputType,
+        trackedEntityTypeId,
+        programId,
+        stageId,
+        searchTerm,
+        dimensionType,
+        nameProp,
+    ])
 
     useEffect(() => {
         if (isListEndVisible && !isLastPage && !fetching) {
diff --git a/src/components/MainSidebar/SelectedDimensionsContext.js b/src/components/MainSidebar/SelectedDimensionsContext.js
index 6c121cd16..f9a42709b 100644
--- a/src/components/MainSidebar/SelectedDimensionsContext.js
+++ b/src/components/MainSidebar/SelectedDimensionsContext.js
@@ -1,4 +1,7 @@
-import { DIMENSION_ID_ORGUNIT } from '@dhis2/analytics'
+import {
+    DIMENSION_ID_ORGUNIT,
+    DIMENSION_TYPE_PROGRAM_ATTRIBUTE,
+} from '@dhis2/analytics'
 import PropTypes from 'prop-types'
 import React, { createContext, useMemo, useContext } from 'react'
 import { useSelector, useStore } from 'react-redux'
@@ -8,13 +11,16 @@ import {
     DIMENSION_TYPES_PROGRAM,
     DIMENSION_TYPES_YOURS,
 } from '../../modules/dimensionConstants.js'
+import { extractDimensionIdParts } from '../../modules/dimensionId.js'
 import { getTimeDimensions } from '../../modules/timeDimensions.js'
-import { sGetUiLayout } from '../../reducers/ui.js'
+import { OUTPUT_TYPE_TRACKED_ENTITY } from '../../modules/visualization.js'
+import { sGetUiInputType, sGetUiLayout } from '../../reducers/ui.js'
 
 const SelectedDimensionsContext = createContext({
     counts: {
         your: 0,
         program: 0,
+        trackedEntity: 0,
     },
     getIsDimensionSelected: () => {
         throw new Error('Context not initialized correctly')
@@ -23,6 +29,7 @@ const SelectedDimensionsContext = createContext({
 
 export const SelectedDimensionsProvider = ({ children }) => {
     const layout = useSelector(sGetUiLayout)
+    const selectedInputType = useSelector(sGetUiInputType)
     const store = useStore()
 
     const providerValue = useMemo(() => {
@@ -45,24 +52,38 @@ export const SelectedDimensionsProvider = ({ children }) => {
             (acc, id) => {
                 const { dimensionType } = metadata[id] ?? {}
 
+                const { dimensionId } = extractDimensionIdParts(
+                    id,
+                    selectedInputType
+                )
+
                 if (
+                    dimensionType === DIMENSION_TYPE_PROGRAM_ATTRIBUTE &&
+                    selectedInputType === OUTPUT_TYPE_TRACKED_ENTITY
+                ) {
+                    acc.trackedEntity += 1
+                } else if (
                     DIMENSION_TYPES_PROGRAM.has(dimensionType) ||
                     [
-                        DIMENSION_ID_ORGUNIT,
                         DIMENSION_ID_EVENT_STATUS,
                         DIMENSION_ID_PROGRAM_STATUS,
                         ...Object.keys(getTimeDimensions()),
-                    ].includes(id)
+                    ].includes(dimensionId)
                 ) {
                     acc.program += 1
-                }
-
-                if (DIMENSION_TYPES_YOURS.has(dimensionType)) {
+                } else if (dimensionId === DIMENSION_ID_ORGUNIT) {
+                    if (selectedInputType !== OUTPUT_TYPE_TRACKED_ENTITY) {
+                        acc.program += 1
+                    } else if (id !== DIMENSION_ID_ORGUNIT) {
+                        // exclude "ou" which is a global dimension, but add count for program org units
+                        acc.program += 1
+                    }
+                } else if (DIMENSION_TYPES_YOURS.has(dimensionType)) {
                     acc.your += 1
                 }
                 return acc
             },
-            { program: 0, your: 0 }
+            { program: 0, your: 0, trackedEntity: 0 }
         )
 
         return {
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsMenuItem.js b/src/components/MainSidebar/TrackedEntityDimensionsMenuItem.js
new file mode 100644
index 000000000..175fce6ce
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsMenuItem.js
@@ -0,0 +1,30 @@
+import i18n from '@dhis2/d2-i18n'
+import { IconFolder16 } from '@dhis2/ui'
+import PropTypes from 'prop-types'
+import React from 'react'
+import { MenuItem } from './MenuItem/index.js'
+
+export const TrackedEntityDimensionsMenuItem = ({
+    selected,
+    count,
+    onClick,
+    name,
+}) => (
+    <MenuItem
+        icon={<IconFolder16 />}
+        label={i18n.t(`{{- itemName}} dimensions`, {
+            itemName: name,
+        })}
+        onClick={onClick}
+        selected={selected}
+        count={count}
+        dataTest="tracked-entity-button"
+    />
+)
+
+TrackedEntityDimensionsMenuItem.propTypes = {
+    name: PropTypes.string.isRequired,
+    onClick: PropTypes.func.isRequired,
+    count: PropTypes.number,
+    selected: PropTypes.bool,
+}
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsPanel/ProgramFilter.js b/src/components/MainSidebar/TrackedEntityDimensionsPanel/ProgramFilter.js
new file mode 100644
index 000000000..c54e1d717
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsPanel/ProgramFilter.js
@@ -0,0 +1,120 @@
+import { useCachedDataQuery } from '@dhis2/analytics'
+import { useDataQuery } from '@dhis2/app-runtime'
+import i18n from '@dhis2/d2-i18n'
+import { NoticeBox, SingleSelect, SingleSelectOption } from '@dhis2/ui'
+import PropTypes from 'prop-types'
+import React, { useEffect } from 'react'
+import { useDispatch, useSelector } from 'react-redux'
+import { acAddMetadata } from '../../../actions/metadata.js'
+import { DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY } from '../../../modules/userSettings.js'
+import { sGetMetadataById } from '../../../reducers/metadata.js'
+import { sGetUiEntityTypeId } from '../../../reducers/ui.js'
+import styles from '../ProgramDimensionsPanel/ProgramSelect.module.css'
+
+const query = {
+    programs: {
+        resource: 'programs',
+        params: ({ nameProp, selectedEntityTypeId }) => ({
+            fields: ['id', `${nameProp}~rename(name)`],
+            paging: false,
+            filter: [
+                'access.data.read:eq:true',
+                `trackedEntityType.id:eq:${selectedEntityTypeId}`,
+            ],
+        }),
+    },
+}
+
+const ProgramFilter = ({ setSelectedProgramId, selectedProgramId }) => {
+    const { currentUser } = useCachedDataQuery()
+    const selectedEntityTypeId = useSelector(sGetUiEntityTypeId)
+    const { fetching, error, data, refetch, called } = useDataQuery(query, {
+        lazy: true,
+    })
+    const programs = data?.programs?.programs
+    const selectedProgram = useSelector((state) =>
+        sGetMetadataById(state, selectedProgramId)
+    )
+    const dispatch = useDispatch()
+
+    useEffect(() => {
+        if (!called) {
+            refetch({
+                nameProp:
+                    currentUser.settings[
+                        DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY
+                    ],
+                selectedEntityTypeId,
+            })
+        }
+    }, [called, currentUser, refetch, selectedEntityTypeId])
+
+    return (
+        <div className={styles.rows}>
+            <div className={styles.columns}>
+                <div className={styles.stretch}>
+                    {error && !fetching ? (
+                        <div className={styles.section}>
+                            <NoticeBox
+                                error
+                                title={i18n.t('Could not load programs')}
+                            >
+                                {error?.message ||
+                                    i18n.t(
+                                        "The programs couldn't be retrieved. Try again or contact your system administrator."
+                                    )}
+                            </NoticeBox>
+                        </div>
+                    ) : (
+                        <SingleSelect
+                            dense
+                            selected={selectedProgramId || ''}
+                            onChange={({ selected }) => {
+                                setSelectedProgramId(selected)
+                                dispatch(
+                                    acAddMetadata({
+                                        [selected]: programs.find(
+                                            (p) => p.id === selected
+                                        ),
+                                    })
+                                )
+                            }}
+                            placeholder={i18n.t('Filter by program usage')}
+                            maxHeight="max(60vh, 460px)"
+                            dataTest="tet-dimensions-program-select"
+                            filterable
+                            noMatchText={i18n.t('No programs found')}
+                            prefix={selectedProgramId && i18n.t('Program')}
+                            clearable
+                            clearText={i18n.t('Clear')}
+                            loading={fetching}
+                        >
+                            {(fetching || !programs) && selectedProgram?.id && (
+                                <SingleSelectOption
+                                    key={selectedProgram?.id}
+                                    label={selectedProgram?.name}
+                                    value={selectedProgram?.id}
+                                />
+                            )}
+                            {!fetching &&
+                                programs?.map(({ id, name }) => (
+                                    <SingleSelectOption
+                                        key={id}
+                                        label={name}
+                                        value={id}
+                                    />
+                                ))}
+                        </SingleSelect>
+                    )}
+                </div>
+            </div>
+        </div>
+    )
+}
+
+ProgramFilter.propTypes = {
+    setSelectedProgramId: PropTypes.func.isRequired,
+    selectedProgramId: PropTypes.string,
+}
+
+export { ProgramFilter }
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.js b/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.js
new file mode 100644
index 000000000..832fcfd97
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.js
@@ -0,0 +1,82 @@
+import { useCachedDataQuery } from '@dhis2/analytics'
+import i18n from '@dhis2/d2-i18n'
+import { Input } from '@dhis2/ui'
+import PropTypes from 'prop-types'
+import React, { useState } from 'react'
+import { useSelector } from 'react-redux'
+import { DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY } from '../../../modules/userSettings.js'
+import { useDebounce } from '../../../modules/utils.js'
+import { sGetMetadataById } from '../../../reducers/metadata.js'
+import { sGetUiEntityTypeId } from '../../../reducers/ui.js'
+import { DimensionsList } from '../DimensionsList/index.js'
+import { ProgramFilter } from './ProgramFilter.js'
+import styles from './TrackedEntityDimensionsPanel.module.css'
+import { useTrackedEntityDimensions } from './useTrackedEntityDimensions.js'
+
+const TrackedEntityDimensionsPanel = ({ visible }) => {
+    const [searchTerm, setSearchTerm] = useState('')
+    const [selectedProgramId, setSelectedProgramId] = useState(null)
+    const selectedEntityTypeId = useSelector(sGetUiEntityTypeId)
+    const entityType = useSelector((state) =>
+        sGetMetadataById(state, selectedEntityTypeId)
+    )
+    const debouncedSearchTerm = useDebounce(searchTerm)
+    const { currentUser } = useCachedDataQuery()
+    const { loading, fetching, error, dimensions, setIsListEndVisible } =
+        useTrackedEntityDimensions({
+            visible,
+            searchTerm: debouncedSearchTerm,
+            nameProp:
+                currentUser.settings[
+                    DERIVED_USER_SETTINGS_DISPLAY_NAME_PROPERTY
+                ],
+            id: selectedEntityTypeId,
+            programId: selectedProgramId,
+        })
+
+    if (!visible) {
+        return null
+    }
+
+    const draggableDimensions = dimensions.map((dimension) => ({
+        draggableId: `tracked-entity-${dimension.id}`,
+        ...dimension,
+    }))
+
+    return (
+        <>
+            <div className={styles.filters}>
+                <Input
+                    value={searchTerm}
+                    onChange={({ value }) => setSearchTerm(value)}
+                    dense
+                    placeholder={i18n.t('Search dimensions')}
+                    type="search"
+                    dataTest="search-te-dimension-input"
+                />
+                <div className={styles.programSelect}>
+                    <ProgramFilter
+                        setSelectedProgramId={setSelectedProgramId}
+                        selectedProgramId={selectedProgramId}
+                    />
+                </div>
+            </div>
+            <DimensionsList
+                setIsListEndVisible={setIsListEndVisible}
+                dimensions={draggableDimensions}
+                error={error}
+                fetching={fetching}
+                loading={loading}
+                searchTerm={debouncedSearchTerm}
+                dataTest="tracked-entity-dimensions"
+                trackedEntityType={entityType?.name}
+            />
+        </>
+    )
+}
+
+TrackedEntityDimensionsPanel.propTypes = {
+    visible: PropTypes.bool,
+}
+
+export { TrackedEntityDimensionsPanel }
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.module.css b/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.module.css
new file mode 100644
index 000000000..b332313e6
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsPanel/TrackedEntityDimensionsPanel.module.css
@@ -0,0 +1,7 @@
+.filters {
+    padding: var(--spacers-dp12) var(--spacers-dp8);
+    border-bottom: 1px solid var(--colors-grey300);
+}
+.programSelect {
+    padding-top: var(--spacers-dp4);
+}
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsPanel/index.js b/src/components/MainSidebar/TrackedEntityDimensionsPanel/index.js
new file mode 100644
index 000000000..5f12f095d
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsPanel/index.js
@@ -0,0 +1 @@
+export { TrackedEntityDimensionsPanel } from './TrackedEntityDimensionsPanel.js'
diff --git a/src/components/MainSidebar/TrackedEntityDimensionsPanel/useTrackedEntityDimensions.js b/src/components/MainSidebar/TrackedEntityDimensionsPanel/useTrackedEntityDimensions.js
new file mode 100644
index 000000000..7017d9012
--- /dev/null
+++ b/src/components/MainSidebar/TrackedEntityDimensionsPanel/useTrackedEntityDimensions.js
@@ -0,0 +1,102 @@
+import { useDataQuery } from '@dhis2/app-runtime'
+import { useEffect, useState } from 'react'
+import { DIMENSION_LIST_FIELDS } from '../DimensionsList/index.js'
+
+const TRACKED_ENTITY_DIMENSIONS_RESOURCE =
+    'analytics/trackedEntities/query/dimensions'
+
+const TRACKED_ENTITY_DIMENSIONS_FILTER = 'dimensionType:eq:PROGRAM_ATTRIBUTE'
+
+const query = {
+    dimensions: {
+        resource: TRACKED_ENTITY_DIMENSIONS_RESOURCE,
+        params: ({ page, searchTerm, nameProp, id, programId }) => {
+            const filters = [TRACKED_ENTITY_DIMENSIONS_FILTER]
+
+            if (searchTerm) {
+                filters.push(`${nameProp}:ilike:${searchTerm}`)
+            }
+
+            return {
+                pageSize: 50,
+                page,
+                fields: [...DIMENSION_LIST_FIELDS, `${nameProp}~rename(name)`],
+                filter: filters,
+                order: `${nameProp}:asc`,
+                trackedEntityType: id,
+                ...(programId ? { program: programId } : {}),
+            }
+        },
+    },
+}
+
+const useTrackedEntityDimensions = ({
+    visible,
+    searchTerm,
+    nameProp,
+    id,
+    programId,
+}) => {
+    const [isListEndVisible, setIsListEndVisible] = useState(false)
+    const [dimensions, setDimensions] = useState(null)
+    const { data, error, loading, fetching, refetch } = useDataQuery(query, {
+        lazy: true,
+    })
+
+    useEffect(() => {
+        // Delay initial fetch until component comes into view
+        if (visible && !dimensions) {
+            refetch({ page: 1, nameProp, id, programId })
+        }
+    }, [visible])
+
+    useEffect(() => {
+        // Reset when filter changes
+        setDimensions(null)
+        if (visible) {
+            refetch({
+                page: 1,
+                searchTerm,
+                nameProp,
+                id,
+                programId,
+            })
+        }
+    }, [searchTerm, id, programId])
+
+    useEffect(() => {
+        if (data) {
+            const { pager } = data.dimensions
+            const isLastPage = pager.pageSize * pager.page >= pager.total
+
+            if (isListEndVisible && !isLastPage && !fetching) {
+                refetch({
+                    page: pager.page + 1,
+                    searchTerm,
+                    nameProp,
+                    id,
+                    programId,
+                })
+            }
+        }
+    }, [isListEndVisible, nameProp])
+
+    useEffect(() => {
+        if (!fetching && data) {
+            setDimensions((currDimensions) => [
+                ...(currDimensions ?? []),
+                ...data.dimensions.dimensions,
+            ])
+        }
+    }, [data, fetching])
+
+    return {
+        loading: dimensions ? false : loading,
+        fetching,
+        error,
+        dimensions: dimensions ?? [],
+        setIsListEndVisible,
+    }
+}
+
+export { useTrackedEntityDimensions }
diff --git a/src/components/MainSidebar/YourDimensionsPanel/YourDimensionsPanel.js b/src/components/MainSidebar/YourDimensionsPanel/YourDimensionsPanel.js
index 741a23eec..72539114f 100644
--- a/src/components/MainSidebar/YourDimensionsPanel/YourDimensionsPanel.js
+++ b/src/components/MainSidebar/YourDimensionsPanel/YourDimensionsPanel.js
@@ -40,8 +40,8 @@ const YourDimensionsPanel = ({ visible }) => {
                     onChange={({ value }) => setSearchTerm(value)}
                     dense
                     placeholder={i18n.t('Search your dimensions')}
-                    type={'search'}
-                    dataTest={'search-dimension-input'}
+                    type="search"
+                    dataTest="search-dimension-input"
                 />
             </div>
             <DimensionsList
diff --git a/src/components/Toolbar/MenuBar.js b/src/components/Toolbar/MenuBar.js
index 07e2b5eb6..632cc01ee 100644
--- a/src/components/Toolbar/MenuBar.js
+++ b/src/components/Toolbar/MenuBar.js
@@ -240,7 +240,7 @@ export const MenuBar = ({ onFileMenuAction }) => {
                         getVisualizationState(current, visualization)
                     ) &&
                     isLayoutValidForSave({
-                        program: current?.program,
+                        ...current,
                         legacy: visualization?.legacy,
                     })
                         ? onSave
diff --git a/src/components/Visualization/Visualization.js b/src/components/Visualization/Visualization.js
index 91eabc25e..f0314950e 100644
--- a/src/components/Visualization/Visualization.js
+++ b/src/components/Visualization/Visualization.js
@@ -59,12 +59,9 @@ import {
     getHeadersMap,
     transformVisualization,
 } from '../../modules/visualization.js'
+import { getAdaptedVisualization } from './analyticsQueryTools.js'
 import styles from './styles/Visualization.module.css'
-import {
-    cellIsUndefined,
-    getAdaptedVisualization,
-    useAnalyticsData,
-} from './useAnalyticsData.js'
+import { cellIsUndefined, useAnalyticsData } from './useAnalyticsData.js'
 
 export const DEFAULT_SORT_DIRECTION = 'asc'
 export const FIRST_PAGE = 1
@@ -225,7 +222,7 @@ export const Visualization = ({
 
     if (headers && sortField) {
         // reset sorting if current sortField has been removed from Columns DHIS2-13948
-        if (!headers.includes(sortField)) {
+        if (!headers.flat().includes(sortField)) {
             setSorting({
                 sortField: null,
                 sortDirection: DEFAULT_SORT_DIRECTION,
@@ -444,7 +441,7 @@ export const Visualization = ({
                       )
                     : undefined
             }
-            dataTest={'table-cell'}
+            dataTest="table-cell"
         >
             <div
                 style={
@@ -544,7 +541,7 @@ export const Visualization = ({
                                                 sizeClass,
                                                 'bordered'
                                             )}
-                                            dataTest={'table-header'}
+                                            dataTest="table-header"
                                         >
                                             {formatCellHeader(header)}
                                         </DataTableColumnHeader>
@@ -558,18 +555,18 @@ export const Visualization = ({
                                                 fontSizeClass,
                                                 sizeClass
                                             )}
-                                            dataTest={'table-header'}
+                                            dataTest="table-header"
                                         />
                                     )
                                 )}
                             </DataTableRow>
                         </DataTableHead>
                         {/* https://jira.dhis2.org/browse/LIBS-278 */}
-                        <DataTableBody dataTest={'table-body'}>
+                        <DataTableBody dataTest="table-body">
                             {data.rows.map((row, rowIndex) => (
                                 <DataTableRow
                                     key={rowIndex}
-                                    dataTest={'table-row'}
+                                    dataTest="table-row"
                                 >
                                     {row.map((value, columnIndex) =>
                                         cellIsUndefined(
@@ -579,6 +576,7 @@ export const Visualization = ({
                                         ) ? (
                                             <Tooltip
                                                 content={i18n.t('No event')}
+                                                key={`${rowIndex}_${columnIndex}-tooltip`}
                                             >
                                                 {(props) =>
                                                     renderCellContent({
diff --git a/src/components/Visualization/__tests__/analyticsQueryTools.spec.js b/src/components/Visualization/__tests__/analyticsQueryTools.spec.js
new file mode 100644
index 000000000..a721bfbc4
--- /dev/null
+++ b/src/components/Visualization/__tests__/analyticsQueryTools.spec.js
@@ -0,0 +1,138 @@
+import { getAdaptedVisualization } from '../analyticsQueryTools.js'
+
+describe('analyticsQueryTools', () => {
+    it('should move enrollmentDate items to parameters', () => {
+        const visualization = {
+            outputType: 'TRACKED_ENTITY_INSTANCE',
+            columns: [
+                {
+                    dimension: 'ou',
+                    items: [
+                        {
+                            id: 'USER_ORGUNIT',
+                        },
+                    ],
+                },
+                {
+                    dimension: 'enrollmentDate',
+                    items: [
+                        {
+                            id: 'theProgramId.THIS_MONTH',
+                        },
+                        {
+                            id: 'theProgramId.LAST_3_MONTHS',
+                        },
+                    ],
+                    programStage: {
+                        id: 'theProgramId',
+                    },
+                },
+            ],
+            rows: [],
+            filters: [],
+        }
+        const expected = {
+            adaptedVisualization: {
+                columns: [
+                    {
+                        dimension: 'ou',
+                        items: [
+                            {
+                                id: 'USER_ORGUNIT',
+                            },
+                        ],
+                    },
+                ],
+                rows: [],
+                filters: [],
+                outputType: 'TRACKED_ENTITY_INSTANCE',
+            },
+            headers: ['ouname', 'theProgramId.enrollmentdate'],
+            parameters: {
+                enrollmentDate: [
+                    'theProgramId.THIS_MONTH',
+                    'theProgramId.LAST_3_MONTHS',
+                ],
+            },
+        }
+        expect(getAdaptedVisualization(visualization)).toEqual(expected)
+    })
+    it('should move enrollmentDate items from 2 programs to parameters', () => {
+        const visualization = {
+            outputType: 'TRACKED_ENTITY_INSTANCE',
+            columns: [
+                {
+                    dimension: 'ou',
+                    items: [
+                        {
+                            id: 'USER_ORGUNIT',
+                        },
+                    ],
+                },
+                {
+                    dimension: 'enrollmentDate',
+                    items: [
+                        {
+                            id: 'program_1_id.LAST_3_MONTHS',
+                        },
+                        {
+                            id: 'program_1_id.LAST_MONTH',
+                        },
+                    ],
+                    programStage: {
+                        id: 'program_1_id',
+                    },
+                },
+                {
+                    dimension: 'enrollmentDate',
+                    items: [
+                        {
+                            id: 'program_2_id.LAST_12_MONTHS',
+                        },
+                        {
+                            id: 'program_2_id.LAST_6_MONTHS',
+                        },
+                    ],
+                    programStage: {
+                        id: 'program_2_id',
+                    },
+                },
+            ],
+            rows: [],
+            filters: [],
+        }
+
+        const expected = {
+            adaptedVisualization: {
+                columns: [
+                    {
+                        dimension: 'ou',
+                        items: [
+                            {
+                                id: 'USER_ORGUNIT',
+                            },
+                        ],
+                    },
+                ],
+                rows: [],
+                filters: [],
+                outputType: 'TRACKED_ENTITY_INSTANCE',
+            },
+            headers: [
+                'ouname',
+                'program_1_id.enrollmentdate',
+                'program_2_id.enrollmentdate',
+            ],
+            parameters: {
+                enrollmentDate: [
+                    'program_1_id.LAST_3_MONTHS',
+                    'program_1_id.LAST_MONTH',
+                    'program_2_id.LAST_12_MONTHS',
+                    'program_2_id.LAST_6_MONTHS',
+                ],
+            },
+        }
+
+        expect(getAdaptedVisualization(visualization)).toEqual(expected)
+    })
+})
diff --git a/src/components/Visualization/analyticsQueryTools.js b/src/components/Visualization/analyticsQueryTools.js
new file mode 100644
index 000000000..7f931b323
--- /dev/null
+++ b/src/components/Visualization/analyticsQueryTools.js
@@ -0,0 +1,134 @@
+import {
+    AXIS_ID_COLUMNS,
+    AXIS_ID_ROWS,
+    AXIS_ID_FILTERS,
+    DIMENSION_ID_ORGUNIT,
+} from '@dhis2/analytics'
+import {
+    DIMENSION_ID_PROGRAM_STATUS,
+    DIMENSION_ID_EVENT_STATUS,
+    DIMENSION_ID_CREATED,
+    DIMENSION_ID_CREATED_BY,
+    DIMENSION_ID_LAST_UPDATED_BY,
+    DIMENSION_IDS_TIME,
+} from '../../modules/dimensionConstants.js'
+import { formatDimensionId } from '../../modules/dimensionId.js'
+import { getRequestOptions } from '../../modules/getRequestOptions.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+    getHeadersMap,
+} from '../../modules/visualization.js'
+
+const excludedDimensions = [
+    DIMENSION_ID_CREATED,
+    DIMENSION_ID_CREATED_BY,
+    DIMENSION_ID_LAST_UPDATED_BY,
+]
+
+const isTimeDimension = (dimensionId) => DIMENSION_IDS_TIME.has(dimensionId)
+
+const adaptDimensions = (dimensions, parameters, outputType) => {
+    const adaptedDimensions = []
+    dimensions.forEach((dimensionObj) => {
+        const dimensionId = dimensionObj.dimension
+
+        if (
+            isTimeDimension(dimensionId) ||
+            dimensionId === DIMENSION_ID_EVENT_STATUS ||
+            dimensionId === DIMENSION_ID_PROGRAM_STATUS ||
+            dimensionId === DIMENSION_ID_CREATED ||
+            (dimensionId === DIMENSION_ID_ORGUNIT &&
+                outputType === OUTPUT_TYPE_TRACKED_ENTITY)
+        ) {
+            if (dimensionObj.items?.length) {
+                const items = dimensionObj.items?.map((item) => item.id)
+                if (
+                    (dimensionId === DIMENSION_ID_PROGRAM_STATUS ||
+                        isTimeDimension(dimensionId)) &&
+                    Array.isArray(parameters[dimensionId])
+                ) {
+                    parameters[dimensionId].push(...items)
+                } else if (dimensionId === DIMENSION_ID_ORGUNIT) {
+                    adaptedDimensions.push(dimensionObj)
+                } else {
+                    parameters[dimensionId] = items
+                }
+            }
+        } else if (!excludedDimensions.includes(dimensionId)) {
+            adaptedDimensions.push(dimensionObj)
+        }
+    })
+
+    return adaptedDimensions
+}
+
+export const getAdaptedVisualization = (visualization) => {
+    const outputType = visualization.outputType
+
+    const parameters = getRequestOptions(visualization)
+
+    const adaptedColumns = adaptDimensions(
+        visualization[AXIS_ID_COLUMNS],
+        parameters,
+        outputType
+    )
+    const adaptedRows = adaptDimensions(
+        visualization[AXIS_ID_ROWS],
+        parameters,
+        outputType
+    )
+    const adaptedFilters = adaptDimensions(
+        visualization[AXIS_ID_FILTERS],
+        parameters,
+        outputType
+    )
+
+    const dimensionHeadersMap = getHeadersMap(visualization)
+
+    const headers = [
+        ...visualization[AXIS_ID_COLUMNS],
+        ...visualization[AXIS_ID_ROWS],
+    ].map(({ dimension, program, programStage, repetition }) => {
+        const programStageId = programStage?.id
+
+        if (repetition?.indexes?.length) {
+            return repetition.indexes.map((index) =>
+                formatDimensionId({
+                    programId: program?.id,
+                    programStageId: `${programStageId}[${index}]`,
+                    dimensionId: dimensionHeadersMap[dimension] || dimension,
+                    outputType,
+                })
+            )
+        } else {
+            return formatDimensionId({
+                programId: program?.id,
+                programStageId,
+                dimensionId: dimensionHeadersMap[dimension] || dimension,
+                outputType,
+            })
+        }
+    })
+
+    return {
+        adaptedVisualization: {
+            [AXIS_ID_COLUMNS]: adaptedColumns,
+            [AXIS_ID_ROWS]: adaptedRows,
+            [AXIS_ID_FILTERS]: adaptedFilters,
+            outputType,
+        },
+        headers,
+        parameters,
+    }
+}
+
+const analyticsApiEndpointMap = {
+    [OUTPUT_TYPE_ENROLLMENT]: 'enrollments',
+    [OUTPUT_TYPE_EVENT]: 'events',
+    [OUTPUT_TYPE_TRACKED_ENTITY]: 'trackedEntities',
+}
+
+export const getAnalyticsEndpoint = (outputType) =>
+    analyticsApiEndpointMap[outputType]
diff --git a/src/components/Visualization/useAnalyticsData.js b/src/components/Visualization/useAnalyticsData.js
index 5c67d8f03..2a3e81dda 100644
--- a/src/components/Visualization/useAnalyticsData.js
+++ b/src/components/Visualization/useAnalyticsData.js
@@ -1,7 +1,4 @@
 import {
-    AXIS_ID_COLUMNS,
-    AXIS_ID_ROWS,
-    AXIS_ID_FILTERS,
     Analytics,
     LEGEND_DISPLAY_STRATEGY_FIXED,
     LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM,
@@ -14,35 +11,29 @@ import {
     VALUE_TYPE_INTEGER_POSITIVE,
     VALUE_TYPE_INTEGER_NEGATIVE,
     VALUE_TYPE_INTEGER_ZERO_OR_POSITIVE,
+    DIMENSION_ID_ORGUNIT,
 } from '@dhis2/analytics'
 import { useDataEngine } from '@dhis2/app-runtime'
 import { useEffect, useState, useRef, useCallback } from 'react'
 import { getBooleanValues, NULL_VALUE } from '../../modules/conditions.js'
+import { DIMENSION_ID_PROGRAM_STATUS } from '../../modules/dimensionConstants.js'
 import {
-    DIMENSION_ID_PROGRAM_STATUS,
-    DIMENSION_ID_EVENT_STATUS,
-    DIMENSION_ID_CREATED_BY,
-    DIMENSION_ID_LAST_UPDATED_BY,
-    DIMENSION_IDS_TIME,
-} from '../../modules/dimensionConstants.js'
-import { getRequestOptions } from '../../modules/getRequestOptions.js'
+    extractDimensionIdParts,
+    formatDimensionId,
+} from '../../modules/dimensionId.js'
+import { getDimensionsWithSuffix } from '../../modules/getDimensionsWithSuffix.js'
+import { getMainDimensions } from '../../modules/mainDimensions.js'
+import { getProgramDimensions } from '../../modules/programDimensions.js'
 import { isAoWithTimeDimension } from '../../modules/timeDimensions.js'
-import { extractDimensionIdParts } from '../../modules/utils.js'
 import {
-    OUTPUT_TYPE_ENROLLMENT,
     OUTPUT_TYPE_EVENT,
-    getHeadersMap,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+    headersMap,
 } from '../../modules/visualization.js'
-
-const analyticsApiEndpointMap = {
-    [OUTPUT_TYPE_ENROLLMENT]: 'enrollments',
-    [OUTPUT_TYPE_EVENT]: 'events',
-}
-
-const excludedDimensions = [
-    DIMENSION_ID_CREATED_BY,
-    DIMENSION_ID_LAST_UPDATED_BY,
-]
+import {
+    getAdaptedVisualization,
+    getAnalyticsEndpoint,
+} from './analyticsQueryTools.js'
 
 const lookupOptionSetOptionMetadata = (optionSetId, code, metaDataItems) => {
     const optionSetMetaData = metaDataItems?.[optionSetId]
@@ -89,70 +80,6 @@ const formatRowValue = ({ rowValue, header, metaDataItems, isUndefined }) => {
     }
 }
 
-const isTimeDimension = (dimensionId) => DIMENSION_IDS_TIME.has(dimensionId)
-
-const getAnalyticsEndpoint = (outputType) => analyticsApiEndpointMap[outputType]
-
-const getAdaptedVisualization = (visualization) => {
-    const parameters = getRequestOptions(visualization)
-
-    const adaptDimensions = (dimensions) => {
-        const adaptedDimensions = []
-        dimensions.forEach((dimensionObj) => {
-            const dimensionId = dimensionObj.dimension
-
-            if (
-                isTimeDimension(dimensionId) ||
-                dimensionId === DIMENSION_ID_EVENT_STATUS ||
-                dimensionId === DIMENSION_ID_PROGRAM_STATUS
-            ) {
-                if (dimensionObj.items?.length) {
-                    parameters[dimensionId] = dimensionObj.items?.map(
-                        (item) => item.id
-                    )
-                }
-            } else if (!excludedDimensions.includes(dimensionId)) {
-                adaptedDimensions.push(dimensionObj)
-            }
-        })
-
-        return adaptedDimensions
-    }
-
-    const adaptedColumns = adaptDimensions(visualization[AXIS_ID_COLUMNS])
-    const adaptedRows = adaptDimensions(visualization[AXIS_ID_ROWS])
-    const adaptedFilters = adaptDimensions(visualization[AXIS_ID_FILTERS])
-
-    const dimensionHeadersMap = getHeadersMap(visualization)
-
-    const headers = [
-        ...visualization[AXIS_ID_COLUMNS],
-        ...visualization[AXIS_ID_ROWS],
-    ].map(({ dimension, programStage, repetition }) => {
-        const headerId = programStage?.id
-            ? `${programStage.id}.${dimension}`
-            : dimensionHeadersMap[dimension] || dimension
-
-        if (repetition?.indexes?.length) {
-            return repetition.indexes.map((index) =>
-                headerId.replace(/\./, `[${index}].`)
-            )
-        } else {
-            return headerId
-        }
-    })
-
-    return {
-        adaptedVisualization: {
-            [AXIS_ID_COLUMNS]: adaptedColumns,
-            [AXIS_ID_ROWS]: adaptedRows,
-            [AXIS_ID_FILTERS]: adaptedFilters,
-        },
-        headers,
-        parameters,
-    }
-}
-
 const fetchAnalyticsData = async ({
     analyticsEngine,
     visualization,
@@ -177,17 +104,26 @@ const fetchAnalyticsData = async ({
                 : {}),
             ...parameters,
         })
-        .withProgram(visualization.program.id)
         .withDisplayProperty(displayProperty.toUpperCase())
-        .withOutputType(visualization.outputType)
         .withPageSize(pageSize)
         .withPage(page)
         .withIncludeMetadataDetails()
 
-    if (visualization.outputType !== OUTPUT_TYPE_ENROLLMENT) {
+    // trackedEntity request can use multiple programs
+    if (visualization.outputType !== OUTPUT_TYPE_TRACKED_ENTITY) {
+        req = req
+            .withProgram(visualization.program.id)
+            .withOutputType(visualization.outputType)
+    }
+
+    if (visualization.outputType === OUTPUT_TYPE_EVENT) {
         req = req.withStage(visualization.programStage?.id)
     }
 
+    if (visualization.outputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        req = req.withTrackedEntityType(visualization.trackedEntityType.id)
+    }
+
     if (relativePeriodDate && isAoWithTimeDimension(visualization)) {
         req = req.withRelativePeriodDate(relativePeriodDate)
     }
@@ -245,22 +181,83 @@ const fetchLegendSets = async ({ legendSetIds, dataEngine }) => {
     return legendSets
 }
 
-const extractHeaders = (analyticsResponse) =>
-    analyticsResponse.headers.map((header, index) => {
-        const result = { ...header, index }
-        const { dimensionId, programStageId } = extractDimensionIdParts(
-            header.name
+const extractHeaders = (analyticsResponse, outputType) => {
+    const defaultMetadata = getMainDimensions(outputType)
+    const dimensionIds = analyticsResponse.headers.map((header) => {
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(header.name, outputType)
+        const idMatch = Object.keys(headersMap).find(
+            (key) => headersMap[key] === dimensionId
         )
+
+        const formattedDimensionId = formatDimensionId({
+            dimensionId: [
+                DIMENSION_ID_ORGUNIT,
+                DIMENSION_ID_PROGRAM_STATUS,
+            ].includes(idMatch)
+                ? idMatch
+                : dimensionId,
+            programStageId,
+            programId,
+            outputType,
+        })
+
         if (
-            programStageId &&
-            analyticsResponse.headers.filter((h) =>
-                h.name.includes(dimensionId)
-            ).length > 1
+            programId &&
+            [DIMENSION_ID_ORGUNIT, DIMENSION_ID_PROGRAM_STATUS].includes(
+                idMatch
+            )
         ) {
-            result.column += ` - ${analyticsResponse.metaData.items[programStageId].name}`
+            defaultMetadata[formattedDimensionId] =
+                getProgramDimensions(programId)[formattedDimensionId]
         }
+
+        return formattedDimensionId
+    })
+
+    const metadata = { ...analyticsResponse.metaData.items, ...defaultMetadata }
+
+    const dimensionsWithSuffix = getDimensionsWithSuffix({
+        dimensionIds,
+        metadata,
+        inputType: outputType,
+    })
+
+    const labels = dimensionsWithSuffix.map(({ name, suffix, id }) => ({
+        id,
+        label: suffix ? `${name}, ${suffix}` : name,
+    }))
+
+    const headers = analyticsResponse.headers.map((header, index) => {
+        const result = { ...header, index }
+        const { dimensionId, programId, programStageId } =
+            extractDimensionIdParts(header.name, outputType)
+
+        const idMatch = Object.keys(headersMap).find(
+            (key) => headersMap[key] === dimensionId
+        )
+
+        result.column =
+            labels.find(
+                (label) =>
+                    label.id ===
+                    formatDimensionId({
+                        dimensionId: [
+                            DIMENSION_ID_ORGUNIT,
+                            DIMENSION_ID_PROGRAM_STATUS,
+                        ].includes(idMatch)
+                            ? idMatch
+                            : dimensionId,
+                        programId,
+                        programStageId,
+                        outputType,
+                    })
+            )?.label || result.column
+
         return result
     })
+    return headers
+}
 
 const extractRows = (analyticsResponse, headers) => {
     const filteredRows = []
@@ -347,7 +344,10 @@ const useAnalyticsData = ({
                 visualization,
                 displayProperty,
             })
-            const headers = extractHeaders(analyticsResponse)
+            const headers = extractHeaders(
+                analyticsResponse,
+                visualization.outputType
+            )
             const rows = extractRows(analyticsResponse, headers)
             const rowContext = extractRowContext(analyticsResponse)
             const pager = analyticsResponse.metaData.pager
@@ -364,7 +364,7 @@ const useAnalyticsData = ({
             if (
                 visualization.legend?.strategy ===
                     LEGEND_DISPLAY_STRATEGY_FIXED &&
-                visualization.legend?.set?.id
+                visualization.legend.set?.id
             ) {
                 legendSetIds.push(visualization.legend.set.id)
             } else if (
@@ -442,6 +442,7 @@ const useAnalyticsData = ({
         sortField,
         sortDirection,
         relativePeriodDate,
+        doFetch,
     ])
 
     useEffect(() => {
@@ -463,4 +464,4 @@ const useAnalyticsData = ({
     }
 }
 
-export { useAnalyticsData, getAnalyticsEndpoint, getAdaptedVisualization }
+export { useAnalyticsData }
diff --git a/src/components/VisualizationOptions/Options/LegendDisplayStyle.js b/src/components/VisualizationOptions/Options/LegendDisplayStyle.js
index d869b4573..b8453f8e9 100644
--- a/src/components/VisualizationOptions/Options/LegendDisplayStyle.js
+++ b/src/components/VisualizationOptions/Options/LegendDisplayStyle.js
@@ -20,7 +20,7 @@ const LegendDisplayStyle = () => (
                 label: i18n.t('Legend changes text color'),
             },
         ]}
-        dataTest={'legend-display-style'}
+        dataTest="legend-display-style"
     />
 )
 
diff --git a/src/components/VisualizationOptions/Options/ShowLegendKey.js b/src/components/VisualizationOptions/Options/ShowLegendKey.js
index f3e57312d..056c8f412 100644
--- a/src/components/VisualizationOptions/Options/ShowLegendKey.js
+++ b/src/components/VisualizationOptions/Options/ShowLegendKey.js
@@ -9,7 +9,7 @@ const ShowLegendKey = () => (
         option={{
             name: OPTION_SHOW_LEGEND_KEY,
         }}
-        dataTest={'option-legend-key'}
+        dataTest="option-legend-key"
     />
 )
 
diff --git a/src/modules/__tests__/conditions.spec.js b/src/modules/__tests__/conditions.spec.js
index 711a2c0f2..e6edccd2c 100644
--- a/src/modules/__tests__/conditions.spec.js
+++ b/src/modules/__tests__/conditions.spec.js
@@ -3,7 +3,12 @@ import {
     checkIsCaseSensitive,
     addCaseSensitivePrefix,
     removeCaseSensitivePrefix,
+    getConditionsFromVisualization,
 } from '../conditions.js'
+import {
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../visualization.js'
 
 test('Legend set chosen with no legends selected', () => {
     const conditions = {
@@ -409,3 +414,75 @@ describe('removeCaseSensitivePrefix', () => {
         })
     })
 })
+
+describe('getConditionsFromVisualization', () => {
+    it('should return empty object if visualization has no columns, rows, or filters', () => {
+        const visualization = {
+            columns: [],
+            rows: [],
+            filters: [],
+        }
+        const conditions = getConditionsFromVisualization(visualization)
+        expect(conditions).toEqual({})
+    })
+
+    it('should return conditions for columns, rows, and filters with filter or legendSet defined', () => {
+        const visualization = {
+            columns: [{ dimension: 'dx1', filter: 'filter1' }],
+            rows: [{ dimension: 'dx2', legendSet: { id: 'legend1' } }],
+            filters: [
+                {
+                    dimension: 'dx3',
+                    filter: 'filter3',
+                    legendSet: { id: 'legend2' },
+                },
+            ],
+        }
+        const conditions = getConditionsFromVisualization(visualization)
+        expect(conditions).toEqual({
+            dx1: { condition: 'filter1', legendSet: undefined },
+            dx2: { condition: undefined, legendSet: 'legend1' },
+            dx3: { condition: 'filter3', legendSet: 'legend2' },
+        })
+    })
+
+    it('should return conditions with correct id for output type event', () => {
+        const visualization = {
+            columns: [
+                {
+                    dimension: 'dx1',
+                    programStage: { id: 'ps1' },
+                    program: { id: 'p1' },
+                    filter: 'filter1',
+                },
+            ],
+            rows: [],
+            filters: [],
+            outputType: OUTPUT_TYPE_EVENT,
+        }
+        const conditions = getConditionsFromVisualization(visualization)
+        expect(conditions).toEqual({
+            'ps1.dx1': { condition: 'filter1', legendSet: undefined },
+        })
+    })
+
+    it('should return conditions with correct id for output type tracked entity', () => {
+        const visualization = {
+            columns: [
+                {
+                    dimension: 'dx1',
+                    programStage: { id: 'ps1' },
+                    program: { id: 'p1' },
+                    filter: 'filter1',
+                },
+            ],
+            rows: [],
+            filters: [],
+            outputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        }
+        const conditions = getConditionsFromVisualization(visualization)
+        expect(conditions).toEqual({
+            'p1.ps1.dx1': { condition: 'filter1', legendSet: undefined },
+        })
+    })
+})
diff --git a/src/modules/__tests__/dimensionId.spec.js b/src/modules/__tests__/dimensionId.spec.js
new file mode 100644
index 000000000..8583505cf
--- /dev/null
+++ b/src/modules/__tests__/dimensionId.spec.js
@@ -0,0 +1,319 @@
+import { formatDimensionId, extractDimensionIdParts } from '../dimensionId.js'
+import {
+    OUTPUT_TYPE_TRACKED_ENTITY,
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_EVENT,
+} from '../visualization.js'
+
+describe('formatDimensionId', () => {
+    it('returns correct result for: dimensionId', () => {
+        const dimensionId = 'did'
+
+        expect(formatDimensionId({ dimensionId })).toEqual('did')
+    })
+    it('returns correct result for: programStageId + dimensionId', () => {
+        const dimensionId = 'did'
+        const programStageId = 'sid'
+
+        expect(formatDimensionId({ dimensionId, programStageId })).toEqual(
+            'sid.did'
+        )
+    })
+    it('returns correct result for: programId + programStageId + dimensionId', () => {
+        const dimensionId = 'did'
+        const programStageId = 'sid'
+        const programId = 'pid'
+
+        expect(
+            formatDimensionId({ dimensionId, programStageId, programId })
+        ).toEqual('sid.did')
+    })
+    it('returns correct result for Tracked Entity: programId + programStageId + dimensionId', () => {
+        const dimensionId = 'did'
+        const programStageId = 'sid'
+        const programId = 'pid'
+
+        expect(
+            formatDimensionId({
+                dimensionId,
+                programStageId,
+                programId,
+                outputType: OUTPUT_TYPE_TRACKED_ENTITY,
+            })
+        ).toEqual('pid.sid.did')
+    })
+})
+
+describe('extractDimensionIdParts', () => {
+    it('returns correct result for: null', () => {
+        const output = extractDimensionIdParts(null)
+
+        expect(output.dimensionId).toEqual('')
+        expect(output.programStageId).toEqual('')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for Tracked Entity: null', () => {
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(null, inputType)
+
+        expect(output.dimensionId).toEqual('')
+        expect(output.programStageId).toEqual('')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for: undefined', () => {
+        const output = extractDimensionIdParts()
+
+        expect(output.dimensionId).toEqual('')
+        expect(output.programStageId).toEqual('')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for Tracked Entity: undefined', () => {
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(undefined, inputType)
+
+        expect(output.dimensionId).toEqual('')
+        expect(output.programStageId).toEqual('')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for: dimensionId', () => {
+        const id = 'did'
+        const output = extractDimensionIdParts(id)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toBeFalsy()
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for: programStageId + dimensionId', () => {
+        const id = 'sid.did'
+        const output = extractDimensionIdParts(id)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for: programStageId + dimensionId + repetitionIndex', () => {
+        const id = 'sid[3].did'
+        const output = extractDimensionIdParts(id)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toEqual('3')
+    })
+    it('returns correct result for Event: programStageId + dimensionId + repetitionIndex', () => {
+        const id = 'sid[3].did'
+        const inputType = OUTPUT_TYPE_EVENT
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toEqual('3')
+    })
+    it('returns correct result for Enrollment: programStageId + dimensionId + repetitionIndex', () => {
+        const id = 'sid[3].did'
+        const inputType = OUTPUT_TYPE_ENROLLMENT
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toEqual('3')
+    })
+    it('returns correct result for: programId + programStageId + dimensionId', () => {
+        const id = 'pid.sid.did'
+        const output = extractDimensionIdParts(id)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toEqual('pid')
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for: programId + programStageId + dimensionId + repetitionIndex', () => {
+        const id = 'pid.sid[3].did'
+        const output = extractDimensionIdParts(id)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toEqual('pid')
+        expect(output.repetitionIndex).toEqual('3')
+    })
+    it('returns correct result for Tracked Entity: programId + programStageId + dimensionId', () => {
+        const id = 'pid.sid.did'
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toEqual('pid')
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for Tracked Entity: programId + programStageId + dimensionId + repetitionIndex', () => {
+        const id = 'pid.sid[3].did'
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toEqual('sid')
+        expect(output.programId).toEqual('pid')
+        expect(output.repetitionIndex).toEqual('3')
+    })
+    it('returns correct result for Tracked Entity: programId + dimensionId', () => {
+        const id = 'pid.did'
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toBeFalsy()
+        expect(output.programId).toEqual('pid')
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+    it('returns correct result for Tracked Entity: dimensionId', () => {
+        const id = 'did'
+        const inputType = OUTPUT_TYPE_TRACKED_ENTITY
+        const output = extractDimensionIdParts(id, inputType)
+
+        expect(output.dimensionId).toEqual('did')
+        expect(output.programStageId).toBeFalsy()
+        expect(output.programId).toBeUndefined()
+        expect(output.repetitionIndex).toBeUndefined()
+    })
+})
+
+describe('formatDimensionId + extractDimensionIdParts', () => {
+    it('returns correct result for: dimensionId', () => {
+        const inputDimensionId = 'did'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(
+                formatDimensionId({
+                    dimensionId: inputDimensionId,
+                })
+            )
+
+        expect(dimensionId).toEqual(inputDimensionId)
+        expect(programStageId).toBeFalsy()
+        expect(programId).toBeUndefined()
+    })
+
+    it('returns correct result for: programStageId + dimensionId', () => {
+        const inputDimensionId = 'did'
+        const inputProgramStageId = 'sid'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(
+                formatDimensionId({
+                    dimensionId: inputDimensionId,
+                    programStageId: inputProgramStageId,
+                })
+            )
+
+        expect(dimensionId).toEqual(inputDimensionId)
+        expect(programStageId).toEqual(inputProgramStageId)
+        expect(programId).toBeUndefined()
+    })
+
+    it('returns correct result for: programId + programStageId + dimensionId', () => {
+        const inputDimensionId = 'did'
+        const inputProgramStageId = 'sid'
+        const inputProgramId = 'pid'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(
+                formatDimensionId({
+                    dimensionId: inputDimensionId,
+                    programStageId: inputProgramStageId,
+                    programId: inputProgramId,
+                })
+            )
+
+        expect(dimensionId).toEqual(inputDimensionId)
+        expect(programStageId).toEqual(inputProgramStageId)
+        expect(programId).toBeUndefined()
+    })
+
+    it('returns correct result for Tracked Entity: programId + programStageId + dimensionId', () => {
+        const inputDimensionId = 'did'
+        const inputProgramStageId = 'sid'
+        const inputProgramId = 'pid'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(
+                formatDimensionId({
+                    dimensionId: inputDimensionId,
+                    programStageId: inputProgramStageId,
+                    programId: inputProgramId,
+                    outputType: OUTPUT_TYPE_TRACKED_ENTITY,
+                }),
+                OUTPUT_TYPE_TRACKED_ENTITY
+            )
+
+        expect(dimensionId).toEqual(inputDimensionId)
+        expect(programStageId).toEqual(inputProgramStageId)
+        expect(programId).toEqual(inputProgramId)
+    })
+})
+
+describe('extractDimensionIdParts + formatDimensionId', () => {
+    it('returns correct result for: dimensionId', () => {
+        const inputId = 'did'
+
+        const { dimensionId } = extractDimensionIdParts(inputId)
+
+        const outputId = formatDimensionId({
+            dimensionId,
+        })
+
+        expect(outputId).toEqual(inputId)
+    })
+
+    it('returns correct result for: programStageId + dimensionId', () => {
+        const inputId = 'sid.did'
+
+        const { dimensionId, programStageId } = extractDimensionIdParts(inputId)
+
+        const outputId = formatDimensionId({
+            dimensionId,
+            programStageId,
+        })
+
+        expect(outputId).toEqual(inputId)
+    })
+
+    it('returns correct result for: programId + programStageId + dimensionId', () => {
+        const inputId = 'sid.did'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(inputId)
+
+        const outputId = formatDimensionId({
+            dimensionId,
+            programStageId,
+            programId,
+        })
+
+        expect(outputId).toEqual(inputId)
+    })
+
+    it('returns correct result for Tracked Entity: programId + programStageId + dimensionId', () => {
+        const inputId = 'pid.sid.did'
+
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(inputId, OUTPUT_TYPE_TRACKED_ENTITY)
+
+        const outputId = formatDimensionId({
+            dimensionId,
+            programStageId,
+            programId,
+            outputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(outputId).toEqual(inputId)
+    })
+})
diff --git a/src/modules/__tests__/getDimensionsWithSuffix.spec.js b/src/modules/__tests__/getDimensionsWithSuffix.spec.js
new file mode 100644
index 000000000..13662b5ab
--- /dev/null
+++ b/src/modules/__tests__/getDimensionsWithSuffix.spec.js
@@ -0,0 +1,770 @@
+import {
+    DIMENSION_TYPE_DATA_ELEMENT,
+    DIMENSION_TYPE_ORGANISATION_UNIT,
+    DIMENSION_TYPE_PERIOD,
+    VALUE_TYPE_TEXT,
+} from '@dhis2/analytics'
+import { DIMENSION_TYPE_STATUS } from '../dimensionConstants.js'
+import { getDimensionsWithSuffix } from '../getDimensionsWithSuffix.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../visualization.js'
+
+describe('getDimensionsWithSuffix for data elements', () => {
+    const metadata = {
+        p1: {
+            id: 'p1',
+            name: 'Program1',
+        },
+        p2: {
+            id: 'p2',
+            name: 'Program2',
+        },
+        p1s1: {
+            id: 'p1s1',
+            name: 'P1 Stage1',
+        },
+        p1s2: {
+            id: 'p1s2',
+            name: 'P1 Stage2',
+        },
+        p2s1: {
+            id: 'p2s1',
+            name: 'P2 Stage1',
+        },
+        p2s2: {
+            id: 'p2s2',
+            name: 'P2 Stage2',
+        },
+        'p1s1.d1': {
+            id: 'p1s1.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1s1.d2': {
+            id: 'p1s1.d2',
+            name: 'Dimension2',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet2',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1s2.d1': {
+            id: 'p1s2.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1s2.d2': {
+            id: 'p1s2.d2',
+            name: 'Dimension2',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet2',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1s2.d3': {
+            id: 'p1s2.d3',
+            name: 'Dimension3',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet3',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1.p1s1.d1': {
+            id: 'p1.p1s1.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1.p1s2.d1': {
+            id: 'p1.p1s2.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p1.p1s2.d2': {
+            id: 'p1.p1s2.d2',
+            name: 'Dimension2',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet2',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p2.p2s1.d1': {
+            id: 'p2.p2s1.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p2.p2s1.d3': {
+            id: 'p2.p2s1.d3',
+            name: 'Dimension3',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet3',
+            valueType: VALUE_TYPE_TEXT,
+        },
+        'p2.p2s2.d1': {
+            id: 'p2.p2s2.d1',
+            name: 'Dimension1',
+            dimensionType: DIMENSION_TYPE_DATA_ELEMENT,
+            optionSet: 'OptionSet1',
+            valueType: VALUE_TYPE_TEXT,
+        },
+    }
+
+    it('returns correct result for: non-TE, no duplicates -> no suffix', () => {
+        const id1 = 'p1s1.d1',
+            id2 = 'p1s1.d2',
+            id3 = 'p1s2.d3'
+        const dimensionIds = [id1, id2, id3]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension2')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet2')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toBeUndefined()
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Dimension3')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[2].optionSet).toEqual('OptionSet3')
+        expect(output[2].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[2].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: non-TE, with duplicates per stage -> stage suffix', () => {
+        const id1 = 'p1s1.d1',
+            id2 = 'p1s2.d1'
+        const dimensionIds = [id1, id2]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toEqual('P1 Stage1')
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension1')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet1')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toEqual('P1 Stage2')
+    })
+
+    it('returns correct result for: TE, no duplicates -> no suffix', () => {
+        const id1 = 'p1.p1s1.d1',
+            id2 = 'p1.p1s2.d2',
+            id3 = 'p2.p2s1.d3'
+        const dimensionIds = [id1, id2, id3]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension2')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet2')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toBeUndefined()
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Dimension3')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[2].optionSet).toEqual('OptionSet3')
+        expect(output[2].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[2].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, with duplicates per stage -> stage suffix', () => {
+        const id1 = 'p1.p1s1.d1',
+            id2 = 'p1.p1s2.d1',
+            id3 = 'p1.p1s2.d2' // no duplicate, just reference
+        const dimensionIds = [id1, id2, id3]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toEqual('P1 Stage1')
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension1')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet1')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toEqual('P1 Stage2')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Dimension2')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[2].optionSet).toEqual('OptionSet2')
+        expect(output[2].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[2].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, with duplicates per program -> program suffix', () => {
+        const id1 = 'p1.p1s1.d1',
+            id2 = 'p2.p2s1.d1',
+            id3 = 'p1.p1s2.d2' // no duplicate, just reference
+        const dimensionIds = [id1, id2, id3]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toEqual('Program1')
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension1')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet1')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toEqual('Program2')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Dimension2')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[2].optionSet).toEqual('OptionSet2')
+        expect(output[2].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[2].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, with duplicates per program and stage -> stage suffix', () => {
+        const id1 = 'p1.p1s1.d1', // stage duplicate of id3
+            id2 = 'p1.p1s2.d1', // stage duplicate of id1
+            id3 = 'p2.p2s1.d1', // program duplicate of id1 and id3
+            id4 = 'p1.p1s2.d2' // no duplicate, just reference
+        const dimensionIds = [id1, id2, id3, id4]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Dimension1')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[0].optionSet).toEqual('OptionSet1')
+        expect(output[0].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[0].suffix).toEqual('P1 Stage1')
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Dimension1')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[1].optionSet).toEqual('OptionSet1')
+        expect(output[1].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[1].suffix).toEqual('P1 Stage2')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Dimension1')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[2].optionSet).toEqual('OptionSet1')
+        expect(output[2].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[2].suffix).toEqual('P2 Stage1')
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Dimension2')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_DATA_ELEMENT)
+        expect(output[3].optionSet).toEqual('OptionSet2')
+        expect(output[3].valueType).toEqual(VALUE_TYPE_TEXT)
+        expect(output[3].suffix).toBeUndefined()
+    })
+})
+
+describe('getDimensionsWithSuffix for time dimensions', () => {
+    const metadata = {
+        p1: {
+            id: 'p1',
+            name: 'Program1',
+        },
+        p2: {
+            id: 'p2',
+            name: 'Program2',
+        },
+        enrollmentDate: {
+            id: 'enrollmentDate',
+            name: 'Date of enrollment',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        eventDate: {
+            id: 'eventDate',
+            name: 'Event date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        incidentDate: {
+            id: 'incidentDate',
+            name: 'Incident date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        scheduledDate: {
+            id: 'scheduledDate',
+            name: 'Scheduled date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p1.enrollmentDate': {
+            id: 'p1.enrollmentDate',
+            name: 'Date of enrollment',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p1.eventDate': {
+            id: 'p1.eventDate',
+            name: 'Event date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p1.incidentDate': {
+            id: 'p1.incidentDate',
+            name: 'Incident date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p1.scheduledDate': {
+            id: 'p1.scheduledDate',
+            name: 'Scheduled date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p2.enrollmentDate': {
+            id: 'p2.enrollmentDate',
+            name: 'Date of enrollment',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p2.eventDate': {
+            id: 'p2.eventDate',
+            name: 'Event date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p2.incidentDate': {
+            id: 'p2.incidentDate',
+            name: 'Incident date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        'p2.scheduledDate': {
+            id: 'p2.scheduledDate',
+            name: 'Scheduled date',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+        lastUpdated: {
+            id: 'lastUpdated',
+            name: 'Last updated on',
+            dimensionType: DIMENSION_TYPE_PERIOD,
+        },
+    }
+
+    it('returns correct result for: non-TE, no duplicates -> no suffix', () => {
+        const id1 = 'eventDate',
+            id2 = 'enrollmentDate',
+            id3 = 'incidentDate',
+            id4 = 'scheduledDate',
+            id5 = 'lastUpdated'
+        const dimensionIds = [id1, id2, id3, id4, id5]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Event date')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Date of enrollment')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[1].suffix).toBeUndefined()
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Incident date')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[2].suffix).toBeUndefined()
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Scheduled date')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[3].suffix).toBeUndefined()
+
+        expect(output[4].id).toEqual(id5)
+        expect(output[4].name).toEqual('Last updated on')
+        expect(output[4].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[4].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, no duplicates -> no suffix', () => {
+        const id1 = 'p1.eventDate',
+            id2 = 'p1.enrollmentDate',
+            id3 = 'p1.incidentDate',
+            id4 = 'p1.scheduledDate',
+            id5 = 'lastUpdated'
+        const dimensionIds = [id1, id2, id3, id4, id5]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Event date')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Date of enrollment')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[1].suffix).toBeUndefined()
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Incident date')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[2].suffix).toBeUndefined()
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Scheduled date')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[3].suffix).toBeUndefined()
+
+        expect(output[4].id).toEqual(id5)
+        expect(output[4].name).toEqual('Last updated on')
+        expect(output[4].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[4].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, duplicates -> program suffix', () => {
+        const id1 = 'p1.eventDate',
+            id2 = 'p1.enrollmentDate',
+            id3 = 'p1.incidentDate',
+            id4 = 'p1.scheduledDate',
+            id5 = 'p2.eventDate',
+            id6 = 'p2.enrollmentDate',
+            id7 = 'p2.incidentDate',
+            id8 = 'p2.scheduledDate',
+            id9 = 'lastUpdated'
+        const dimensionIds = [id1, id2, id3, id4, id5, id6, id7, id8, id9]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Event date')
+        expect(output[0].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[0].suffix).toEqual('Program1')
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Date of enrollment')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[1].suffix).toEqual('Program1')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Incident date')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[2].suffix).toEqual('Program1')
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Scheduled date')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[3].suffix).toEqual('Program1')
+
+        expect(output[4].id).toEqual(id5)
+        expect(output[4].name).toEqual('Event date')
+        expect(output[4].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[4].suffix).toEqual('Program2')
+
+        expect(output[5].id).toEqual(id6)
+        expect(output[5].name).toEqual('Date of enrollment')
+        expect(output[5].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[5].suffix).toEqual('Program2')
+
+        expect(output[6].id).toEqual(id7)
+        expect(output[6].name).toEqual('Incident date')
+        expect(output[6].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[6].suffix).toEqual('Program2')
+
+        expect(output[7].id).toEqual(id8)
+        expect(output[7].name).toEqual('Scheduled date')
+        expect(output[7].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[7].suffix).toEqual('Program2')
+
+        expect(output[8].id).toEqual(id9)
+        expect(output[8].name).toEqual('Last updated on')
+        expect(output[8].dimensionType).toEqual(DIMENSION_TYPE_PERIOD)
+        expect(output[8].suffix).toBeUndefined()
+    })
+})
+
+describe('getDimensionsWithSuffix for program dimensions', () => {
+    const metadata = {
+        p1: {
+            id: 'p1',
+            name: 'Program1',
+        },
+        p2: {
+            id: 'p2',
+            name: 'Program2',
+        },
+        ou: {
+            id: 'ou',
+            name: 'Organisation unit',
+            dimensionType: DIMENSION_TYPE_ORGANISATION_UNIT,
+        },
+        'p1.ou': {
+            id: 'p1.ou',
+            name: 'Organisation unit',
+            dimensionType: DIMENSION_TYPE_ORGANISATION_UNIT,
+        },
+        'p2.ou': {
+            id: 'p2.ou',
+            name: 'Organisation unit',
+            dimensionType: DIMENSION_TYPE_ORGANISATION_UNIT,
+        },
+        eventStatus: {
+            id: 'eventStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Event status',
+        },
+        programStatus: {
+            id: 'programStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Program status',
+        },
+        'p1.eventStatus': {
+            id: 'p1.eventStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Event status',
+        },
+        'p1.programStatus': {
+            id: 'p1.programStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Program status',
+        },
+        'p2.eventStatus': {
+            id: 'p2.eventStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Event status',
+        },
+        'p2.programStatus': {
+            id: 'p2.programStatus',
+            dimensionType: DIMENSION_TYPE_STATUS,
+            name: 'Program status',
+        },
+        XYZ123: {
+            aggregationType: 'NONE',
+            dimensionItemType: 'DATA_ELEMENT',
+            name: 'Some data element',
+            totalAggregationType: 'SUM',
+            uid: 'XYZ123',
+            valueType: 'TEXT',
+        },
+        'p1.p1s1.XYZ123': {
+            aggregationType: 'NONE',
+            dimensionItemType: 'DATA_ELEMENT',
+            name: 'Some data element 1',
+            totalAggregationType: 'SUM',
+            uid: 'XYZ123',
+            valueType: 'TEXT',
+        },
+        'p2.p2s1.XYZ123': {
+            aggregationType: 'NONE',
+            dimensionItemType: 'DATA_ELEMENT',
+            name: 'Some data element 2',
+            totalAggregationType: 'SUM',
+            uid: 'XYZ123',
+            valueType: 'TEXT',
+        },
+    }
+
+    it('returns correct result for: non-TE, no duplicates -> no suffix', () => {
+        const id1 = 'ou',
+            id2 = 'eventStatus',
+            id3 = 'programStatus',
+            id4 = 'p1.p1s1.XYZ123'
+        const dimensionIds = [id1, id2, id3, id4]
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_ENROLLMENT,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Organisation unit')
+        expect(output[0].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Event status')
+        expect(output[1].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[1].suffix).toBeUndefined()
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Program status')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[2].suffix).toBeUndefined()
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Some data element 1')
+        expect(output[3].dimensionType).toBeUndefined()
+        expect(output[3].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, no duplicates -> program suffix for ou and statuses', () => {
+        const id1 = 'ou',
+            id2 = 'p1.ou',
+            id3 = 'p1.eventStatus',
+            id4 = 'p1.programStatus',
+            id5 = 'p1.p1s1.XYZ123'
+        const dimensionIds = [id1, id2, id3, id4, id5]
+
+        metadata.ou.name = 'Registration org. unit'
+
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Registration org. unit')
+        expect(output[0].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Organisation unit')
+        expect(output[1].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[1].suffix).toEqual('Program1')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Event status')
+        expect(output[2].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[2].suffix).toEqual('Program1')
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Program status')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[3].suffix).toEqual('Program1')
+
+        expect(output[4].id).toEqual(id5)
+        expect(output[4].name).toEqual('Some data element 1')
+        expect(output[4].dimensionType).toBeUndefined()
+        expect(output[4].suffix).toBeUndefined()
+    })
+
+    it('returns correct result for: TE, duplicates -> program suffix', () => {
+        const id1 = 'ou',
+            id2 = 'p1.ou',
+            id3 = 'p2.ou',
+            id4 = 'p1.eventStatus',
+            id5 = 'p2.eventStatus',
+            id6 = 'p1.programStatus',
+            id7 = 'p2.programStatus',
+            id8 = 'p1.p1s1.XYZ123',
+            id9 = 'p2.p2s1.XYZ123'
+        const dimensionIds = [id1, id2, id3, id4, id5, id6, id7, id8, id9]
+
+        metadata.ou.name = 'Registration org. unit'
+
+        const output = getDimensionsWithSuffix({
+            dimensionIds,
+            metadata,
+            inputType: OUTPUT_TYPE_TRACKED_ENTITY,
+        })
+
+        expect(output[0].id).toEqual(id1)
+        expect(output[0].name).toEqual('Registration org. unit')
+        expect(output[0].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[0].suffix).toBeUndefined()
+
+        expect(output[1].id).toEqual(id2)
+        expect(output[1].name).toEqual('Organisation unit')
+        expect(output[1].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[1].suffix).toEqual('Program1')
+
+        expect(output[2].id).toEqual(id3)
+        expect(output[2].name).toEqual('Organisation unit')
+        expect(output[2].dimensionType).toEqual(
+            DIMENSION_TYPE_ORGANISATION_UNIT
+        )
+        expect(output[2].suffix).toEqual('Program2')
+
+        expect(output[3].id).toEqual(id4)
+        expect(output[3].name).toEqual('Event status')
+        expect(output[3].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[3].suffix).toEqual('Program1')
+
+        expect(output[4].id).toEqual(id5)
+        expect(output[4].name).toEqual('Event status')
+        expect(output[4].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[4].suffix).toEqual('Program2')
+
+        expect(output[5].id).toEqual(id6)
+        expect(output[5].name).toEqual('Program status')
+        expect(output[5].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[5].suffix).toEqual('Program1')
+
+        expect(output[6].id).toEqual(id7)
+        expect(output[6].name).toEqual('Program status')
+        expect(output[6].dimensionType).toEqual(DIMENSION_TYPE_STATUS)
+        expect(output[6].suffix).toEqual('Program2')
+
+        expect(output[7].id).toEqual(id8)
+        expect(output[7].name).toEqual('Some data element 1')
+        expect(output[7].dimensionType).toBeUndefined()
+        expect(output[7].suffix).toEqual('Program1')
+
+        expect(output[8].id).toEqual(id9)
+        expect(output[8].name).toEqual('Some data element 2')
+        expect(output[8].dimensionType).toBeUndefined()
+        expect(output[8].suffix).toEqual('Program2')
+    })
+})
diff --git a/src/modules/__tests__/metadata.spec.js b/src/modules/__tests__/metadata.spec.js
new file mode 100644
index 000000000..2d4db3326
--- /dev/null
+++ b/src/modules/__tests__/metadata.spec.js
@@ -0,0 +1,85 @@
+import { getDynamicTimeDimensionsMetadata } from '../metadata.js'
+
+describe('getDynamicTimeDimensionsMetadata', () => {
+    it('should return correct dynamic time dimensions metadata when inputType is OUTPUT_TYPE_TRACKED_ENTITY', () => {
+        const program = {
+            id: 'programId',
+            displayEnrollmentDateLabel: 'Custom Enrollment Date',
+            displayIncidentDateLabel: 'Custom Incident Date',
+        }
+        const stage = { displayExecutionDateLabel: 'Stage Execution Date' }
+        const inputType = 'TRACKED_ENTITY_INSTANCE' // OUTPUT_TYPE_TRACKED_ENTITY
+
+        const result = getDynamicTimeDimensionsMetadata(
+            program,
+            stage,
+            inputType
+        )
+
+        const expected = {
+            'programId.eventDate': {
+                id: 'programId.eventDate',
+                dimensionType: 'PERIOD',
+                name: 'Stage Execution Date',
+            },
+            'programId.enrollmentDate': {
+                id: 'programId.enrollmentDate',
+                dimensionType: 'PERIOD',
+                name: 'Custom Enrollment Date',
+            },
+            'programId.incidentDate': {
+                id: 'programId.incidentDate',
+                dimensionType: 'PERIOD',
+                name: 'Custom Incident Date',
+            },
+            'programId.scheduledDate': {
+                id: 'programId.scheduledDate',
+                dimensionType: 'PERIOD',
+                name: 'Scheduled date',
+            },
+        }
+
+        expect(result).toEqual(expected)
+    })
+
+    it('should return correct dynamic time dimensions metadata when inputType is not OUTPUT_TYPE_TRACKED_ENTITY', () => {
+        const program = {
+            id: 'programId',
+            displayEnrollmentDateLabel: 'Program Enrollment Date',
+            displayIncidentDateLabel: 'Custom Incident Date',
+        }
+        const stage = { displayExecutionDateLabel: 'Stage Execution Date' }
+        const inputType = 'OTHER_TYPE'
+
+        const result = getDynamicTimeDimensionsMetadata(
+            program,
+            stage,
+            inputType
+        )
+
+        const expected = {
+            eventDate: {
+                id: 'eventDate',
+                dimensionType: 'PERIOD',
+                name: 'Stage Execution Date',
+            },
+            enrollmentDate: {
+                id: 'enrollmentDate',
+                dimensionType: 'PERIOD',
+                name: 'Program Enrollment Date',
+            },
+            incidentDate: {
+                id: 'incidentDate',
+                dimensionType: 'PERIOD',
+                name: 'Custom Incident Date',
+            },
+            scheduledDate: {
+                id: 'scheduledDate',
+                dimensionType: 'PERIOD',
+                name: 'Scheduled date',
+            },
+        }
+
+        expect(result).toEqual(expected)
+    })
+})
diff --git a/src/modules/__tests__/options.spec.js b/src/modules/__tests__/options.spec.js
new file mode 100644
index 000000000..87251d635
--- /dev/null
+++ b/src/modules/__tests__/options.spec.js
@@ -0,0 +1,68 @@
+import {
+    LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM,
+    LEGEND_DISPLAY_STYLE_FILL,
+} from '@dhis2/analytics'
+import {
+    OPTION_LEGEND_DISPLAY_STRATEGY,
+    OPTION_LEGEND_DISPLAY_STYLE,
+    OPTION_LEGEND_SET,
+    OPTION_SHOW_LEGEND_KEY,
+    getOptionsFromVisualization,
+} from '../options.js'
+
+describe('getOptionsFromVisualization', () => {
+    it('should return default options if visualization is empty', () => {
+        const visualization = {}
+        const result = getOptionsFromVisualization(visualization)
+        expect(result).toEqual({
+            digitGroupSeparator: 'SPACE',
+            displayDensity: 'NORMAL',
+            fontSize: 'NORMAL',
+            showHierarchy: false,
+            skipRounding: false,
+        })
+    })
+
+    it('should return options from visualization', () => {
+        const visualization = {
+            digitGroupSeparator: 'COMMA',
+            displayDensity: 'COMPACT',
+            fontSize: 'SMALL',
+            showHierarchy: true,
+            skipRounding: true,
+        }
+
+        const result = getOptionsFromVisualization(visualization)
+        expect(result).toEqual({
+            digitGroupSeparator: 'COMMA',
+            displayDensity: 'COMPACT',
+            fontSize: 'SMALL',
+            showHierarchy: true,
+            skipRounding: true,
+        })
+    })
+
+    it('should include legend options if present in visualization', () => {
+        const visualization = {
+            legend: {
+                strategy: LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM,
+                style: LEGEND_DISPLAY_STYLE_FILL,
+                set: 'legendSet1',
+                showKey: true,
+            },
+        }
+        const result = getOptionsFromVisualization(visualization)
+        expect(result).toEqual({
+            digitGroupSeparator: 'SPACE',
+            displayDensity: 'NORMAL',
+            fontSize: 'NORMAL',
+            showHierarchy: false,
+            skipRounding: false,
+            [OPTION_LEGEND_DISPLAY_STRATEGY]:
+                LEGEND_DISPLAY_STRATEGY_BY_DATA_ITEM,
+            [OPTION_LEGEND_DISPLAY_STYLE]: LEGEND_DISPLAY_STYLE_FILL,
+            [OPTION_LEGEND_SET]: 'legendSet1',
+            [OPTION_SHOW_LEGEND_KEY]: true,
+        })
+    })
+})
diff --git a/src/modules/__tests__/parentGraphMap.spec.js b/src/modules/__tests__/parentGraphMap.spec.js
new file mode 100644
index 000000000..b0b65041b
--- /dev/null
+++ b/src/modules/__tests__/parentGraphMap.spec.js
@@ -0,0 +1,62 @@
+import { getParentGraphMapFromVisualization } from '../parentGraphMap.js'
+
+describe('getParentGraphMapFromVisualization', () => {
+    it('returns an empty object when no org unit axis exists', () => {
+        const visualization = {
+            columns: [{ dimension: 'dx' }],
+            filters: [],
+        }
+        const parentGraphMap = getParentGraphMapFromVisualization(visualization)
+        expect(parentGraphMap).toEqual({})
+    })
+
+    it('returns parent graph map correctly for org units', () => {
+        const visualization = {
+            columns: [
+                { dimension: 'dx' },
+                {
+                    dimension: 'ou',
+                    items: [
+                        { id: 'orgUnit1', path: '/orgUnit1' },
+                        { id: 'orgUnit2', path: '/orgUnit1/orgUnit2' },
+                        { id: 'orgUnit3', path: '/orgUnit1/orgUnit3' },
+                    ],
+                },
+            ],
+        }
+        const parentGraphMap = getParentGraphMapFromVisualization(visualization)
+        expect(parentGraphMap).toEqual({
+            orgUnit1: '',
+            orgUnit2: 'orgUnit1',
+            orgUnit3: 'orgUnit1',
+        })
+    })
+
+    it('handles root org unit case correctly', () => {
+        const visualization = {
+            columns: [
+                { dimension: 'dx' },
+                {
+                    dimension: 'ou',
+                    items: [{ id: 'rootOrgUnit', path: '/rootOrgUnit' }],
+                },
+            ],
+        }
+        const parentGraphMap = getParentGraphMapFromVisualization(visualization)
+        expect(parentGraphMap).toEqual({ rootOrgUnit: '' })
+    })
+
+    it('handles org unit paths with trailing slashes correctly', () => {
+        const visualization = {
+            columns: [
+                { dimension: 'dx' },
+                {
+                    dimension: 'ou',
+                    items: [{ id: 'orgUnit', path: '/orgUnit/' }],
+                },
+            ],
+        }
+        const parentGraphMap = getParentGraphMapFromVisualization(visualization)
+        expect(parentGraphMap).toEqual({ orgUnit: 'orgUnit' })
+    })
+})
diff --git a/src/modules/__tests__/ui.spec.js b/src/modules/__tests__/repetition.spec.js
similarity index 97%
rename from src/modules/__tests__/ui.spec.js
rename to src/modules/__tests__/repetition.spec.js
index a366c0668..0348ea442 100644
--- a/src/modules/__tests__/ui.spec.js
+++ b/src/modules/__tests__/repetition.spec.js
@@ -3,11 +3,10 @@ import {
     getDefaultCurrentRepetition,
     parseCurrentRepetition,
     parseUiRepetition,
-    PARSE_CURRENT_REPETITION_ERROR,
     PROP_OLDEST,
     PROP_MOST_RECENT,
     PARSE_UI_REPETITION_ERROR,
-} from '../ui.js'
+} from '../repetition.js'
 
 describe('parseCurrentRepetition', () => {
     const defaultUiRepetition = getDefaultUiRepetition()
@@ -38,7 +37,7 @@ describe('parseCurrentRepetition', () => {
 
         invalidInputs.forEach((input) => {
             expect(() => parseCurrentRepetition(input)).toThrow(
-                PARSE_CURRENT_REPETITION_ERROR
+                'parseCurrentRepetition: Invalid input'
             )
         })
 
diff --git a/src/modules/__tests__/timeDimensions.spec.js b/src/modules/__tests__/timeDimensions.spec.js
index 3a718e77c..35a669a59 100644
--- a/src/modules/__tests__/timeDimensions.spec.js
+++ b/src/modules/__tests__/timeDimensions.spec.js
@@ -36,7 +36,7 @@ describe('ER > Dimensions > getTimeDimensionName', () => {
         }
         Object.values(getTimeDimensions()).forEach((dimension) => {
             expect(getTimeDimensionName(dimension, program, stage)).toEqual(
-                dimension.name
+                dimension.defaultName
             )
         })
     })
@@ -57,16 +57,16 @@ describe('ER > Dimensions > getTimeDimensionName', () => {
 
         expect(
             getTimeDimensionName(eventDateDimension, program, stage)
-        ).toEqual(stage.displayExecutionDateLabel)
+        ).toEqual('le event date')
         expect(
             getTimeDimensionName(enrollmentDateDimension, program, stage)
-        ).toEqual(enrollmentDateDimension.name)
+        ).toEqual('Enrollment date')
         expect(
             getTimeDimensionName(incidentDateDimension, program, stage)
-        ).toEqual(incidentDateDimension.name)
+        ).toEqual('Incident date')
         expect(
             getTimeDimensionName(scheduledDateDimension, program, stage)
-        ).toEqual(scheduledDateDimension.name)
+        ).toEqual('Scheduled date')
     })
     it('uses displayEnrollmentDateLabel from program for enrollment date', () => {
         const program = {
@@ -85,16 +85,16 @@ describe('ER > Dimensions > getTimeDimensionName', () => {
 
         expect(
             getTimeDimensionName(eventDateDimension, program, stage)
-        ).toEqual(eventDateDimension.name)
+        ).toEqual('Event date')
         expect(
             getTimeDimensionName(enrollmentDateDimension, program, stage)
-        ).toEqual(program.displayEnrollmentDateLabel)
+        ).toEqual('le enrollment date')
         expect(
             getTimeDimensionName(incidentDateDimension, program, stage)
-        ).toEqual(incidentDateDimension.name)
+        ).toEqual('Incident date')
         expect(
             getTimeDimensionName(scheduledDateDimension, program, stage)
-        ).toEqual(scheduledDateDimension.name)
+        ).toEqual('Scheduled date')
     })
     it('uses displayDueDateLabel from stage for scheduled date', () => {
         const program = {
@@ -113,16 +113,16 @@ describe('ER > Dimensions > getTimeDimensionName', () => {
 
         expect(
             getTimeDimensionName(eventDateDimension, program, stage)
-        ).toEqual(eventDateDimension.name)
+        ).toEqual('Event date')
         expect(
             getTimeDimensionName(enrollmentDateDimension, program, stage)
-        ).toEqual(enrollmentDateDimension.name)
+        ).toEqual('Enrollment date')
         expect(
             getTimeDimensionName(incidentDateDimension, program, stage)
-        ).toEqual(incidentDateDimension.name)
+        ).toEqual('Incident date')
         expect(
             getTimeDimensionName(scheduledDateDimension, program, stage)
-        ).toEqual(stage.displayDueDateLabel)
+        ).toEqual('le due date')
     })
     it('uses displayIncidentDateLabel from program for incident date', () => {
         const program = {
@@ -141,16 +141,16 @@ describe('ER > Dimensions > getTimeDimensionName', () => {
 
         expect(
             getTimeDimensionName(eventDateDimension, program, stage)
-        ).toEqual(eventDateDimension.name)
+        ).toEqual('Event date')
         expect(
             getTimeDimensionName(enrollmentDateDimension, program, stage)
-        ).toEqual(enrollmentDateDimension.name)
+        ).toEqual('Enrollment date')
         expect(
             getTimeDimensionName(incidentDateDimension, program, stage)
-        ).toEqual(program.displayIncidentDateLabel)
+        ).toEqual('le incident date')
         expect(
             getTimeDimensionName(scheduledDateDimension, program, stage)
-        ).toEqual(scheduledDateDimension.name)
+        ).toEqual('Scheduled date')
     })
 })
 
diff --git a/src/modules/__tests__/utils.spec.js b/src/modules/__tests__/utils.spec.js
deleted file mode 100644
index 70378d3d6..000000000
--- a/src/modules/__tests__/utils.spec.js
+++ /dev/null
@@ -1,69 +0,0 @@
-import { formatDimensionId, extractDimensionIdParts } from '../utils.js'
-
-describe('formatDimensionId', () => {
-    it('returns correct result when only dimensionId is used', () => {
-        const dimensionId = 'myDimensionId'
-
-        expect(formatDimensionId(dimensionId)).toEqual('myDimensionId')
-    })
-    it('returns correct result when both programStageId and dimensionId are used', () => {
-        const dimensionId = 'myDimensionId'
-        const programStageId = 'myProgramStageId'
-
-        expect(formatDimensionId(dimensionId, programStageId)).toEqual(
-            'myProgramStageId.myDimensionId'
-        )
-    })
-})
-
-describe('extractDimensionIdParts', () => {
-    it('returns correct result when only dimensionId is used', () => {
-        const input = 'myDimensionId'
-
-        expect(extractDimensionIdParts(input).dimensionId).toEqual(
-            'myDimensionId'
-        )
-        expect(extractDimensionIdParts(input).programStageId).toBeFalsy()
-        expect(extractDimensionIdParts(input).repetitionIndex).toBeUndefined()
-    })
-    it('returns correct result when both programStageId and dimensionId are used', () => {
-        const input = 'myProgramStageId.myDimensionId'
-
-        expect(extractDimensionIdParts(input).dimensionId).toEqual(
-            'myDimensionId'
-        )
-        expect(extractDimensionIdParts(input).programStageId).toEqual(
-            'myProgramStageId'
-        )
-        expect(extractDimensionIdParts(input).repetitionIndex).toBeUndefined()
-    })
-    it('returns correct result when both programStageId and dimensionId are used with repetitionIndex', () => {
-        const input = 'myProgramStageId[3].myDimensionId'
-
-        expect(extractDimensionIdParts(input).dimensionId).toEqual(
-            'myDimensionId'
-        )
-        expect(extractDimensionIdParts(input).programStageId).toEqual(
-            'myProgramStageId'
-        )
-        expect(extractDimensionIdParts(input).repetitionIndex).toEqual('3')
-    })
-})
-
-describe('formatDimensionId + extractDimensionIdParts', () => {
-    it('returns correct result when both programStageId and dimensionId are used', () => {
-        const dimensionId = 'myDimensionId'
-        const programStageId = 'myProgramStageId'
-
-        expect(
-            extractDimensionIdParts(
-                formatDimensionId(dimensionId, programStageId)
-            ).dimensionId
-        ).toEqual(dimensionId)
-        expect(
-            extractDimensionIdParts(
-                formatDimensionId(dimensionId, programStageId)
-            ).programStageId
-        ).toEqual(programStageId)
-    })
-})
diff --git a/src/modules/conditions.js b/src/modules/conditions.js
index 57c1a78dd..10e196b6d 100644
--- a/src/modules/conditions.js
+++ b/src/modules/conditions.js
@@ -23,6 +23,7 @@ import {
     DIMENSION_TYPE_PROGRAM_INDICATOR,
 } from '@dhis2/analytics'
 import i18n from '@dhis2/d2-i18n'
+import { formatDimensionId } from './dimensionId.js'
 
 // parse e.g. 'LT:25:GT:15' to ['LT:25', 'GT:15']
 export const parseConditionsStringToArray = (conditionsString) =>
@@ -271,3 +272,22 @@ export const getConditionsTexts = ({
 
     return parsedConditions
 }
+
+export const getConditionsFromVisualization = (vis) =>
+    [...vis.columns, ...vis.rows, ...vis.filters]
+        .filter((item) => item.filter || item.legendSet)
+        .reduce(
+            (acc, key) => ({
+                ...acc,
+                [formatDimensionId({
+                    dimensionId: key.dimension,
+                    programStageId: key.programStage?.id,
+                    programId: key.program?.id,
+                    outputType: vis.outputType,
+                })]: {
+                    condition: key.filter,
+                    legendSet: key.legendSet?.id,
+                },
+            }),
+            {}
+        )
diff --git a/src/modules/current.js b/src/modules/current.js
index 349db37de..a9d8a9f87 100644
--- a/src/modules/current.js
+++ b/src/modules/current.js
@@ -1,5 +1,6 @@
 import { dimensionCreate, VIS_TYPE_LINE_LIST } from '@dhis2/analytics'
 import pick from 'lodash-es/pick'
+import { extractDimensionIdParts } from './dimensionId.js'
 import { BASE_FIELD_TYPE } from './fields.js'
 import { getAdaptedUiLayoutByType } from './layout.js'
 import {
@@ -9,8 +10,8 @@ import {
     OPTION_LEGEND_SET,
     OPTION_SHOW_LEGEND_KEY,
 } from './options.js'
-import { parseUiRepetition } from './ui.js'
-import { extractDimensionIdParts } from './utils.js'
+import { parseUiRepetition } from './repetition.js'
+import { OUTPUT_TYPE_TRACKED_ENTITY } from './visualization.js'
 
 export const getDefaultFromUi = (current, ui) => {
     const adaptedUi = {
@@ -21,18 +22,34 @@ export const getDefaultFromUi = (current, ui) => {
         itemsByDimension: getItemsByDimensionFromUi(ui),
     }
 
-    return {
+    const output = {
         // merge with current if current is a saved visualization to keep id, access etc
         ...(current?.id && current),
         [BASE_FIELD_TYPE]: adaptedUi.type,
         outputType: adaptedUi.input.type,
+        ...getEntityTypeFromUi(adaptedUi),
         ...getProgramFromUi(adaptedUi),
         ...getProgramStageFromUi(adaptedUi),
         ...getAxesFromUi(adaptedUi),
         ...getOptionsFromUi(adaptedUi),
     }
+
+    if (output.outputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        // delete program and programStage if output type is TE as the api doesn't accept these props at all
+        delete output.program
+        delete output.programStage
+    } else {
+        // delete trackedEntityType if output type is not TE
+        delete output.trackedEntityType
+    }
+
+    return output
 }
 
+export const getEntityTypeFromUi = (ui) => ({
+    trackedEntityType: { id: ui.entityType?.id },
+})
+
 export const getProgramFromUi = (ui) => ({
     program: { id: ui.program?.id },
 })
@@ -58,7 +75,7 @@ export const getAxesFromUi = (ui) =>
             ...layout,
             [axisId]: dimensionIds
                 .map((id) => {
-                    const { dimensionId, programStageId } =
+                    const { programId, programStageId, dimensionId } =
                         extractDimensionIdParts(id)
 
                     return dimensionCreate(
@@ -79,6 +96,11 @@ export const getAxesFromUi = (ui) =>
                                         ),
                                     },
                                 }),
+                            ...(programId && {
+                                program: {
+                                    id: programId,
+                                },
+                            }),
                             ...(programStageId && {
                                 programStage: {
                                     id: programStageId,
diff --git a/src/modules/dimensionConstants.js b/src/modules/dimensionConstants.js
index f461bb598..8bbecd5b1 100644
--- a/src/modules/dimensionConstants.js
+++ b/src/modules/dimensionConstants.js
@@ -38,6 +38,7 @@ export const DIMENSION_ID_ENROLLMENT_DATE = 'enrollmentDate'
 export const DIMENSION_ID_INCIDENT_DATE = 'incidentDate'
 export const DIMENSION_ID_SCHEDULED_DATE = 'scheduledDate'
 export const DIMENSION_ID_LAST_UPDATED = 'lastUpdated'
+export const DIMENSION_ID_CREATED = 'created'
 
 export const DIMENSION_IDS_TIME = new Set([
     DIMENSION_ID_EVENT_DATE,
diff --git a/src/modules/dimensionId.js b/src/modules/dimensionId.js
new file mode 100644
index 000000000..8d00ce200
--- /dev/null
+++ b/src/modules/dimensionId.js
@@ -0,0 +1,37 @@
+import { OUTPUT_TYPE_TRACKED_ENTITY } from './visualization.js'
+
+export const formatDimensionId = ({
+    dimensionId,
+    programStageId,
+    programId,
+    outputType,
+}) => {
+    return [
+        outputType === OUTPUT_TYPE_TRACKED_ENTITY ? programId : undefined,
+        programStageId,
+        dimensionId,
+    ]
+        .filter((p) => p)
+        .join('.')
+}
+
+export const extractDimensionIdParts = (id, inputType) => {
+    let rawStageId
+    const [dimensionId, part2, part3] = (id || '').split('.').reverse()
+    let programId = part3
+    if (part3 || inputType !== OUTPUT_TYPE_TRACKED_ENTITY) {
+        rawStageId = part2
+    }
+    if (inputType === OUTPUT_TYPE_TRACKED_ENTITY && !part3) {
+        programId = part2
+    }
+    const [programStageId, repetitionIndex] = (rawStageId || '').split('[')
+    return {
+        dimensionId,
+        programStageId,
+        ...(programId ? { programId } : {}),
+        repetitionIndex:
+            repetitionIndex?.length &&
+            repetitionIndex.substring(0, repetitionIndex.indexOf(']')),
+    }
+}
diff --git a/src/modules/error.js b/src/modules/error.js
index 021f68378..f156a0c84 100644
--- a/src/modules/error.js
+++ b/src/modules/error.js
@@ -39,6 +39,13 @@ export const visualizationNotFoundError = () =>
         )
     )
 
+export const noEntityTypeError = () =>
+    visualizationError(
+        EmptyBox,
+        i18n.t('No tracked entity type selected'),
+        i18n.t('Choose a type from the Input sidebar.')
+    )
+
 export const noProgramError = () =>
     visualizationError(
         EmptyBox,
diff --git a/src/modules/getDimensionsWithSuffix.js b/src/modules/getDimensionsWithSuffix.js
new file mode 100644
index 000000000..71855c59c
--- /dev/null
+++ b/src/modules/getDimensionsWithSuffix.js
@@ -0,0 +1,88 @@
+import {
+    DIMENSION_TYPE_DATA_ELEMENT,
+    DIMENSION_TYPE_ORGANISATION_UNIT,
+    DIMENSION_TYPE_PERIOD,
+} from '@dhis2/analytics'
+import { DIMENSION_TYPE_STATUS } from './dimensionConstants.js'
+import { extractDimensionIdParts } from './dimensionId.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from './visualization.js'
+
+export const getDimensionsWithSuffix = ({
+    dimensionIds,
+    metadata,
+    inputType,
+}) => {
+    const dimensions = dimensionIds.map((id) => {
+        const { dimensionId, programStageId, programId } =
+            extractDimensionIdParts(id, inputType)
+        const dimension = {
+            ...metadata[id],
+            dimensionId,
+            programStageId,
+            programId,
+        }
+        if (!dimension.id) {
+            dimension.id = id
+        }
+        return dimension
+    })
+
+    if (
+        ![OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_TRACKED_ENTITY].includes(
+            inputType
+        )
+    ) {
+        return dimensions
+    }
+
+    return dimensions.map((dimension) => {
+        if (
+            [DIMENSION_TYPE_DATA_ELEMENT, DIMENSION_TYPE_PERIOD].includes(
+                dimension.dimensionType || dimension.dimensionItemType
+            )
+        ) {
+            const duplicates = dimensions.filter(
+                (d) =>
+                    d.dimensionId === dimension.dimensionId &&
+                    d !== dimension &&
+                    ((dimension.programId && d.programId) ||
+                        (dimension.programStageId && d.programStageId))
+            )
+
+            if (duplicates.length > 0) {
+                const sameProgramId = duplicates.find(
+                    (dup) => dup.programId === dimension.programId
+                )
+                const thirdPartyDuplicates = duplicates
+                    .filter((dup) => dup.programId !== dimension.programId)
+                    .find((dpid) =>
+                        duplicates.find(
+                            (dup) =>
+                                dup.programStageId !== dpid.programStageId &&
+                                dup.programId === dpid.programId
+                        )
+                    )
+
+                if (sameProgramId || thirdPartyDuplicates) {
+                    dimension.suffix = metadata[dimension.programStageId]?.name
+                } else {
+                    dimension.suffix = metadata[dimension.programId]?.name
+                }
+            }
+        } else if (
+            // always suffix ou and statuses for TE
+            inputType === OUTPUT_TYPE_TRACKED_ENTITY &&
+            [DIMENSION_TYPE_ORGANISATION_UNIT, DIMENSION_TYPE_STATUS].includes(
+                dimension.dimensionType || dimension.dimensionItemType
+            ) &&
+            dimension.programId
+        ) {
+            dimension.suffix = metadata[dimension.programId]?.name
+        }
+
+        return dimension
+    })
+}
diff --git a/src/modules/input.js b/src/modules/input.js
deleted file mode 100644
index 96c68f03e..000000000
--- a/src/modules/input.js
+++ /dev/null
@@ -1,3 +0,0 @@
-export const getInputTypeFromVisualization = (vis) => ({
-    type: vis.outputType,
-})
diff --git a/src/modules/layoutValidation.js b/src/modules/layoutValidation.js
index 8994823fb..e96e59cc8 100644
--- a/src/modules/layoutValidation.js
+++ b/src/modules/layoutValidation.js
@@ -5,7 +5,13 @@ import {
     VIS_TYPE_LINE_LIST,
     DIMENSION_ID_ORGUNIT,
 } from '@dhis2/analytics'
-import { noColumnsError, noOrgUnitError, noProgramError } from './error.js'
+import {
+    noColumnsError,
+    noEntityTypeError,
+    noOrgUnitError,
+    noProgramError,
+} from './error.js'
+import { OUTPUT_TYPE_TRACKED_ENTITY } from './visualization.js'
 
 // Layout validation helper functions
 const isAxisValid = (axis) =>
@@ -21,8 +27,22 @@ export const validateLineListLayout = (layout, { dryRun } = {}) => {
         return false
     }
 
+    // entity type (input type TE only)
+    if (
+        layout.outputType === OUTPUT_TYPE_TRACKED_ENTITY &&
+        !layoutHasTrackedEntityTypeId(layout)
+    ) {
+        if (dryRun) {
+            return false
+        }
+        throw noEntityTypeError()
+    }
+
     // program
-    if (!layoutHasProgramId(layout)) {
+    if (
+        layout.outputType !== OUTPUT_TYPE_TRACKED_ENTITY &&
+        !layoutHasProgramId(layout)
+    ) {
         if (dryRun) {
             return false
         }
@@ -40,6 +60,7 @@ export const validateLineListLayout = (layout, { dryRun } = {}) => {
     // organisation unit
     const ouDimension = layoutGetDimension(layout, DIMENSION_ID_ORGUNIT)
     if (
+        layout.outputType !== OUTPUT_TYPE_TRACKED_ENTITY &&
         !(ouDimension && dimensionIsValid(ouDimension, { requireItems: true }))
     ) {
         if (dryRun) {
@@ -61,9 +82,17 @@ export const validateLayout = (layout) => {
 
 export const layoutHasProgramId = (layout) => Boolean(layout?.program?.id)
 
+export const layoutHasTrackedEntityTypeId = (layout) =>
+    Boolean(layout?.trackedEntityType?.id)
+
 export const aoCreatedInEventReportsApp = (layout) => layout?.legacy
 
 export const isLayoutValidForSave = (layout) =>
-    layoutHasProgramId(layout) && !aoCreatedInEventReportsApp(layout)
+    layout?.outputType === OUTPUT_TYPE_TRACKED_ENTITY
+        ? layoutHasTrackedEntityTypeId(layout)
+        : layoutHasProgramId(layout) && !aoCreatedInEventReportsApp(layout)
 
-export const isLayoutValidForSaveAs = (layout) => layoutHasProgramId(layout)
+export const isLayoutValidForSaveAs = (layout) =>
+    layout?.outputType === OUTPUT_TYPE_TRACKED_ENTITY
+        ? layoutHasTrackedEntityTypeId(layout)
+        : layoutHasProgramId(layout)
diff --git a/src/modules/mainDimensions.js b/src/modules/mainDimensions.js
index eff4a67a9..848f411d6 100644
--- a/src/modules/mainDimensions.js
+++ b/src/modules/mainDimensions.js
@@ -1,13 +1,30 @@
 import { DIMENSION_TYPE_PERIOD } from '@dhis2/analytics'
 import i18n from '@dhis2/d2-i18n'
 import {
+    DIMENSION_ID_CREATED,
     DIMENSION_ID_CREATED_BY,
     DIMENSION_ID_LAST_UPDATED,
     DIMENSION_ID_LAST_UPDATED_BY,
     DIMENSION_TYPE_USER,
 } from './dimensionConstants.js'
+import { getDefaultOuMetadata } from './metadata.js'
+import { OUTPUT_TYPE_TRACKED_ENTITY } from './visualization.js'
 
-export const getMainDimensions = () => ({
+export const getCreatedDimension = () => ({
+    [DIMENSION_ID_CREATED]: {
+        id: DIMENSION_ID_CREATED,
+        dimensionType: DIMENSION_TYPE_PERIOD,
+        name: i18n.t('Registration date'),
+    },
+})
+
+export const getMainDimensions = (inputType) => ({
+    ...(inputType === OUTPUT_TYPE_TRACKED_ENTITY
+        ? {
+              ...getDefaultOuMetadata(inputType),
+              ...getCreatedDimension(),
+          }
+        : {}),
     [DIMENSION_ID_LAST_UPDATED]: {
         id: DIMENSION_ID_LAST_UPDATED,
         dimensionType: DIMENSION_TYPE_PERIOD,
diff --git a/src/modules/metadata.js b/src/modules/metadata.js
index 05c67e52d..0ff4596e8 100644
--- a/src/modules/metadata.js
+++ b/src/modules/metadata.js
@@ -1,13 +1,16 @@
 import {
+    DIMENSION_ID_ORGUNIT,
+    DIMENSION_TYPE_ORGANISATION_UNIT,
     USER_ORG_UNIT,
     USER_ORG_UNIT_CHILDREN,
     USER_ORG_UNIT_GRANDCHILDREN,
 } from '@dhis2/analytics'
 import i18n from '@dhis2/d2-i18n'
-import { getMainDimensions } from './mainDimensions.js'
+import { formatDimensionId } from './dimensionId.js'
+import { getMainDimensions, getCreatedDimension } from './mainDimensions.js'
 import { getProgramDimensions } from './programDimensions.js'
 import { getTimeDimensions, getTimeDimensionName } from './timeDimensions.js'
-import { getStatusNames } from './visualization.js'
+import { OUTPUT_TYPE_TRACKED_ENTITY, getStatusNames } from './visualization.js'
 
 const formatObject = (object) =>
     Object.entries(object).reduce(
@@ -23,6 +26,7 @@ const getOrganisationUnits = () => ({
 
 export const getDefaultMetadata = () => ({
     ...getMainDimensions(),
+    ...getCreatedDimension(),
     ...getProgramDimensions(),
     ...getDefaultTimeDimensionsMetadata(),
     ...formatObject(getOrganisationUnits()),
@@ -43,6 +47,22 @@ export const getDefaultTimeDimensionsMetadata = () => {
     )
 }
 
+export const getDefaultOuMetadata = (inputType) => ({
+    [DIMENSION_ID_ORGUNIT]: {
+        id: DIMENSION_ID_ORGUNIT,
+        dimensionType: DIMENSION_TYPE_ORGANISATION_UNIT,
+        name: getDefaultOrgUnitLabel(inputType),
+    },
+})
+
+export const getDefaultOrgUnitLabel = (inputType) => {
+    if (inputType === OUTPUT_TYPE_TRACKED_ENTITY) {
+        return i18n.t('Registration org. unit')
+    } else {
+        return i18n.t('Organisation unit')
+    }
+}
+
 export const getProgramAsMetadata = (program) => ({
     ...program.programStages.reduce((acc, stage) => {
         acc[stage.id] = stage
@@ -51,10 +71,20 @@ export const getProgramAsMetadata = (program) => ({
     [program.id]: program,
 })
 
-export const getDynamicTimeDimensionsMetadata = (program, stage) => ({
+export const getDynamicTimeDimensionsMetadata = (
+    program,
+    stage,
+    inputType
+) => ({
     ...Object.values(getTimeDimensions()).reduce((acc, dimension) => {
-        acc[dimension.id] = {
-            id: dimension.id,
+        const id = formatDimensionId({
+            dimensionId: dimension.id,
+            programId: program?.id,
+            outputType: inputType,
+        })
+
+        acc[id] = {
+            id,
             dimensionType: dimension.dimensionType,
             name: getTimeDimensionName(dimension, program, stage),
         }
diff --git a/src/modules/parentGraphMap.js b/src/modules/parentGraphMap.js
new file mode 100644
index 000000000..a5a0da054
--- /dev/null
+++ b/src/modules/parentGraphMap.js
@@ -0,0 +1,36 @@
+import {
+    DIMENSION_ID_ORGUNIT,
+    layoutGetAxisIdDimensionIdsObject,
+} from '@dhis2/analytics'
+import { getInverseLayout } from './layout.js'
+import { removeLastPathSegment } from './orgUnit.js'
+
+export const getParentGraphMapFromVisualization = (vis) => {
+    const dimensionIdsByAxis = layoutGetAxisIdDimensionIdsObject(vis)
+    const inverseLayout = getInverseLayout(dimensionIdsByAxis)
+    const ouAxis = inverseLayout[DIMENSION_ID_ORGUNIT]
+
+    if (!ouAxis) {
+        return {}
+    }
+
+    const parentGraphMap = {}
+    const ouDimension = vis[ouAxis].find(
+        (dimension) => dimension.dimension === DIMENSION_ID_ORGUNIT
+    )
+
+    ouDimension.items
+        .filter((orgUnit) => orgUnit.path)
+        .forEach((orgUnit) => {
+            if ('/' + orgUnit.id === orgUnit.path) {
+                // root org unit case
+                parentGraphMap[orgUnit.id] = ''
+            } else {
+                const path = removeLastPathSegment(orgUnit.path)
+                parentGraphMap[orgUnit.id] =
+                    path[0] === '/' ? path.substr(1) : path
+            }
+        })
+
+    return parentGraphMap
+}
diff --git a/src/modules/program.js b/src/modules/program.js
deleted file mode 100644
index d59f1d5f1..000000000
--- a/src/modules/program.js
+++ /dev/null
@@ -1,6 +0,0 @@
-export const getProgramFromVisualisation = (vis) => {
-    return {
-        id: vis.program?.id,
-        stageId: vis.programStage?.id,
-    }
-}
diff --git a/src/modules/programDimensions.js b/src/modules/programDimensions.js
index 0dbe61e48..494797e79 100644
--- a/src/modules/programDimensions.js
+++ b/src/modules/programDimensions.js
@@ -8,22 +8,31 @@ import {
     DIMENSION_TYPE_STATUS,
     DIMENSION_ID_PROGRAM_STATUS,
 } from './dimensionConstants.js'
+import { extractDimensionIdParts } from './dimensionId.js'
+import { getDefaultOrgUnitLabel } from './metadata.js'
 import { PROGRAM_TYPE_WITHOUT_REGISTRATION } from './programTypes.js'
-import { OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_EVENT } from './visualization.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from './visualization.js'
+
+const prefixDimensionId = (prefix, dimensionId) =>
+    prefix ? `${prefix}.${dimensionId}` : dimensionId
 
-export const getProgramDimensions = () => ({
-    [DIMENSION_ID_ORGUNIT]: {
-        id: DIMENSION_ID_ORGUNIT,
+export const getProgramDimensions = (programId) => ({
+    [prefixDimensionId(programId, DIMENSION_ID_ORGUNIT)]: {
+        id: prefixDimensionId(programId, DIMENSION_ID_ORGUNIT),
         dimensionType: DIMENSION_TYPE_ORGANISATION_UNIT,
-        name: i18n.t('Organisation unit'),
+        name: getDefaultOrgUnitLabel(),
     },
-    [DIMENSION_ID_EVENT_STATUS]: {
-        id: DIMENSION_ID_EVENT_STATUS,
+    [prefixDimensionId(programId, DIMENSION_ID_EVENT_STATUS)]: {
+        id: prefixDimensionId(programId, DIMENSION_ID_EVENT_STATUS),
         dimensionType: DIMENSION_TYPE_STATUS,
         name: i18n.t('Event status'),
     },
-    [DIMENSION_ID_PROGRAM_STATUS]: {
-        id: DIMENSION_ID_PROGRAM_STATUS,
+    [prefixDimensionId(programId, DIMENSION_ID_PROGRAM_STATUS)]: {
+        id: prefixDimensionId(programId, DIMENSION_ID_PROGRAM_STATUS),
         dimensionType: DIMENSION_TYPE_STATUS,
         name: i18n.t('Program status'),
     },
@@ -34,18 +43,16 @@ export const getIsProgramDimensionDisabled = ({
     inputType,
     programType,
 }) => {
-    if (
-        dimensionId === DIMENSION_ID_PROGRAM_STATUS &&
-        inputType === OUTPUT_TYPE_EVENT
-    ) {
+    const { dimensionId: id } = extractDimensionIdParts(dimensionId, inputType)
+    if (id === DIMENSION_ID_PROGRAM_STATUS && inputType === OUTPUT_TYPE_EVENT) {
         if (!programType) {
             return true
         } else if (programType === PROGRAM_TYPE_WITHOUT_REGISTRATION) {
             return true
         }
     } else if (
-        dimensionId === DIMENSION_ID_EVENT_STATUS &&
-        inputType === OUTPUT_TYPE_ENROLLMENT
+        id === DIMENSION_ID_EVENT_STATUS &&
+        [OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_TRACKED_ENTITY].includes(inputType)
     ) {
         return true
     }
diff --git a/src/modules/repetition.js b/src/modules/repetition.js
index 143efd952..3b6c31567 100644
--- a/src/modules/repetition.js
+++ b/src/modules/repetition.js
@@ -1,5 +1,17 @@
 import { layoutGetAllDimensions } from '@dhis2/analytics'
-import { parseCurrentRepetition } from './ui.js'
+import isObject from 'lodash-es/isObject'
+import { formatDimensionId } from './dimensionId.js'
+
+const PARSE_CURRENT_REPETITION_ERROR = 'parseCurrentRepetition: Invalid input'
+
+export const PROP_MOST_RECENT = 'mostRecent'
+export const PROP_OLDEST = 'oldest'
+
+export const getDefaultCurrentRepetition = () => []
+export const getDefaultUiRepetition = () => ({
+    [PROP_MOST_RECENT]: 1,
+    [PROP_OLDEST]: 0,
+})
 
 export const getRepetitionFromVisualisation = (vis) => {
     const repetitionByDimension = {}
@@ -7,10 +19,63 @@ export const getRepetitionFromVisualisation = (vis) => {
         .filter((d) => d.repetition)
         .forEach((d) => {
             repetitionByDimension[
-                d.programStage?.id
-                    ? `${d.programStage.id}.${d.dimension}`
-                    : d.dimension
+                formatDimensionId({
+                    dimensionId: d.dimension,
+                    programStageId: d.programStage?.id,
+                    programId: d.program?.id,
+                    outputType: vis.outputType,
+                })
             ] = parseCurrentRepetition(d.repetition.indexes)
         })
     return repetitionByDimension
 }
+
+export const parseCurrentRepetition = (repetition) => {
+    if (
+        !(
+            Array.isArray(repetition) &&
+            repetition.every((i) => Number.isFinite(i))
+        )
+    ) {
+        throw new Error(PARSE_CURRENT_REPETITION_ERROR)
+    }
+
+    return repetition.length
+        ? {
+              [PROP_MOST_RECENT]: repetition.filter((n) => n < 1).length,
+              [PROP_OLDEST]: repetition.filter((n) => n > 0).length,
+          }
+        : getDefaultUiRepetition()
+}
+
+export const PARSE_UI_REPETITION_ERROR = 'parseUiRepetition: Invalid input'
+
+export const parseUiRepetition = (repetition) => {
+    if (
+        !(
+            isObject(repetition) &&
+            Number.isFinite(repetition[PROP_MOST_RECENT]) &&
+            repetition[PROP_MOST_RECENT] >= 0 &&
+            Number.isFinite(repetition[PROP_OLDEST]) &&
+            repetition[PROP_OLDEST] >= 0
+        )
+    ) {
+        throw new Error(PARSE_UI_REPETITION_ERROR)
+    }
+
+    // default
+    if (
+        repetition[PROP_OLDEST] === 0 &&
+        [0, 1].includes(repetition[PROP_MOST_RECENT])
+    ) {
+        return getDefaultCurrentRepetition()
+    }
+
+    return [
+        ...new Array(repetition[PROP_OLDEST]).fill().map((_, i) => i + 1),
+        ...new Array(repetition[PROP_MOST_RECENT])
+            .fill()
+            .map((_, i) => -i + 0)
+            .sort((a, b) => a - b),
+    ]
+}
diff --git a/src/modules/tableValues.js b/src/modules/tableValues.js
index 0a6925315..973aa3982 100644
--- a/src/modules/tableValues.js
+++ b/src/modules/tableValues.js
@@ -12,14 +12,18 @@ import {
     DIMENSION_ID_PROGRAM_STATUS,
     DIMENSION_ID_LAST_UPDATED,
 } from './dimensionConstants.js'
+import { extractDimensionIdParts } from './dimensionId.js'
 import { headersMap, getStatusNames } from './visualization.js'
 
 const getFormattedCellValue = ({ value, header = {}, visualization = {} }) => {
     if (
+        header.name &&
         [
             headersMap[DIMENSION_ID_EVENT_STATUS],
             headersMap[DIMENSION_ID_PROGRAM_STATUS],
-        ].includes(header.name)
+        ].includes(
+            extractDimensionIdParts(header.name, visualization.type).dimensionId
+        )
     ) {
         return getStatusNames()[value] || value
     }
@@ -56,23 +60,23 @@ const getHeaderText = ({ stageOffset, column } = {}) => {
     }
 
     if (Number.isInteger(stageOffset)) {
-        let postfix
+        let repetitionSuffix
 
         if (stageOffset === 0) {
-            postfix = i18n.t('most recent')
+            repetitionSuffix = i18n.t('most recent')
         } else if (stageOffset === 1) {
-            postfix = i18n.t('oldest')
+            repetitionSuffix = i18n.t('oldest')
         } else if (stageOffset > 1) {
-            postfix = i18n.t('oldest {{repeatEventIndex}}', {
+            repetitionSuffix = i18n.t('oldest {{repeatEventIndex}}', {
                 repeatEventIndex: `+${stageOffset - 1}`,
             })
         } else if (stageOffset < 0) {
-            postfix = i18n.t('most recent {{repeatEventIndex}}', {
+            repetitionSuffix = i18n.t('most recent {{repeatEventIndex}}', {
                 repeatEventIndex: stageOffset,
             })
         }
 
-        return `${column} (${postfix})`
+        return `${column} (${repetitionSuffix})`
     }
 
     return column
diff --git a/src/modules/timeDimensions.js b/src/modules/timeDimensions.js
index d315629bb..727b7291a 100644
--- a/src/modules/timeDimensions.js
+++ b/src/modules/timeDimensions.js
@@ -8,7 +8,11 @@ import {
     DIMENSION_IDS_TIME,
 } from './dimensionConstants.js'
 import { PROGRAM_TYPE_WITH_REGISTRATION } from './programTypes.js'
-import { OUTPUT_TYPE_ENROLLMENT, OUTPUT_TYPE_EVENT } from './visualization.js'
+import {
+    OUTPUT_TYPE_ENROLLMENT,
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from './visualization.js'
 
 const NAME_PARENT_PROPERTY_PROGRAM = 'program'
 const NAME_PARENT_PROPERTY_STAGE = 'stage'
@@ -17,28 +21,28 @@ export const getTimeDimensions = () => ({
     [DIMENSION_ID_EVENT_DATE]: {
         id: DIMENSION_ID_EVENT_DATE,
         dimensionType: DIMENSION_TYPE_PERIOD,
-        name: i18n.t('Event date'),
+        defaultName: i18n.t('Event date'),
         nameParentProperty: NAME_PARENT_PROPERTY_STAGE,
         nameProperty: 'displayExecutionDateLabel',
     },
     [DIMENSION_ID_ENROLLMENT_DATE]: {
         id: DIMENSION_ID_ENROLLMENT_DATE,
         dimensionType: DIMENSION_TYPE_PERIOD,
-        name: i18n.t('Enrollment date'),
+        defaultName: i18n.t('Enrollment date'),
         nameParentProperty: NAME_PARENT_PROPERTY_PROGRAM,
         nameProperty: 'displayEnrollmentDateLabel',
     },
     [DIMENSION_ID_INCIDENT_DATE]: {
         id: DIMENSION_ID_INCIDENT_DATE,
         dimensionType: DIMENSION_TYPE_PERIOD,
-        name: i18n.t('Incident date'),
+        defaultName: i18n.t('Incident date'),
         nameParentProperty: NAME_PARENT_PROPERTY_PROGRAM,
         nameProperty: 'displayIncidentDateLabel',
     },
     [DIMENSION_ID_SCHEDULED_DATE]: {
         id: DIMENSION_ID_SCHEDULED_DATE,
         dimensionType: DIMENSION_TYPE_PERIOD,
-        name: i18n.t('Scheduled date'),
+        defaultName: i18n.t('Scheduled date'),
         nameParentProperty: NAME_PARENT_PROPERTY_STAGE,
         nameProperty: 'displayDueDateLabel',
     },
@@ -46,14 +50,14 @@ export const getTimeDimensions = () => ({
 
 export const getTimeDimensionName = (dimension, program, stage) => {
     if (!dimension.nameParentProperty || !program) {
-        return dimension.name
+        return dimension.defaultName
     }
     const name =
         dimension.nameParentProperty === NAME_PARENT_PROPERTY_PROGRAM
             ? program[dimension.nameProperty]
             : stage?.[dimension.nameProperty]
 
-    return name || dimension.name
+    return name || dimension.defaultName
 }
 
 export const getHiddenTimeDimensions = (inputType, program, stage) => {
@@ -75,7 +79,8 @@ export const getHiddenTimeDimensions = (inputType, program, stage) => {
             }
             return hiddenDimensions
         }
-        case OUTPUT_TYPE_ENROLLMENT: {
+        case OUTPUT_TYPE_ENROLLMENT:
+        case OUTPUT_TYPE_TRACKED_ENTITY: {
             hiddenDimensions.push(DIMENSION_ID_EVENT_DATE)
             hiddenDimensions.push(DIMENSION_ID_SCHEDULED_DATE)
 
diff --git a/src/modules/ui.js b/src/modules/ui.js
index ff7e9fbba..8cf71c458 100644
--- a/src/modules/ui.js
+++ b/src/modules/ui.js
@@ -1,16 +1,13 @@
 import {
-    DIMENSION_ID_ORGUNIT,
     layoutGetAxisIdDimensionIdsObject,
     layoutGetDimensionIdItemIdsObject,
     VIS_TYPE_LINE_LIST,
     VIS_TYPE_PIVOT_TABLE,
 } from '@dhis2/analytics'
-import isObject from 'lodash-es/isObject'
-import { getInputTypeFromVisualization } from './input.js'
-import { getAdaptedUiLayoutByType, getInverseLayout } from './layout.js'
+import { getConditionsFromVisualization } from './conditions.js'
+import { getAdaptedUiLayoutByType } from './layout.js'
 import { getOptionsFromVisualization } from './options.js'
-import { removeLastPathSegment } from './orgUnit.js'
-import { getProgramFromVisualisation } from './program.js'
+import { getParentGraphMapFromVisualization } from './parentGraphMap.js'
 import { getRepetitionFromVisualisation } from './repetition.js'
 
 const lineListUiAdapter = (ui) => ({
@@ -30,8 +27,14 @@ export const getAdaptedUiByType = (ui) => {
 
 export const getUiFromVisualization = (vis, currentState = {}) => ({
     ...currentState,
-    input: getInputTypeFromVisualization(vis),
-    program: getProgramFromVisualisation(vis),
+    input: {
+        type: vis.outputType,
+    },
+    entityType: vis.trackedEntityType,
+    program: {
+        id: vis.program?.id,
+        stageId: vis.programStage?.id,
+    },
     options: getOptionsFromVisualization(vis),
     layout: layoutGetAxisIdDimensionIdsObject(vis),
     itemsByDimension: layoutGetDimensionIdItemIdsObject(vis),
@@ -43,116 +46,7 @@ export const getUiFromVisualization = (vis, currentState = {}) => ({
     repetitionByDimension: getRepetitionFromVisualisation(vis),
 })
 
-export const getParentGraphMapFromVisualization = (vis) => {
-    const dimensionIdsByAxis = layoutGetAxisIdDimensionIdsObject(vis)
-    const inverseLayout = getInverseLayout(dimensionIdsByAxis)
-    const ouAxis = inverseLayout[DIMENSION_ID_ORGUNIT]
-
-    if (!ouAxis) {
-        return {}
-    }
-
-    const parentGraphMap = {}
-    const ouDimension = vis[ouAxis].find(
-        (dimension) => dimension.dimension === DIMENSION_ID_ORGUNIT
-    )
-
-    ouDimension.items
-        .filter((orgUnit) => orgUnit.path)
-        .forEach((orgUnit) => {
-            if ('/' + orgUnit.id === orgUnit.path) {
-                // root org unit case
-                parentGraphMap[orgUnit.id] = ''
-            } else {
-                const path = removeLastPathSegment(orgUnit.path)
-                parentGraphMap[orgUnit.id] =
-                    path[0] === '/' ? path.substr(1) : path
-            }
-        })
-
-    return parentGraphMap
-}
-
-const getConditionsFromVisualization = (vis) =>
-    [...vis.columns, ...vis.rows, ...vis.filters]
-        .filter((item) => item.filter || item.legendSet)
-        .reduce(
-            (acc, key) => ({
-                ...acc,
-                [key.programStage?.id
-                    ? `${key.programStage.id}.${key.dimension}`
-                    : key.dimension]: {
-                    condition: key.filter,
-                    legendSet: key.legendSet?.id,
-                },
-            }),
-            {}
-        )
-
 export const ACCESSORY_PANEL_TAB_INPUT = 'INPUT'
 export const ACCESSORY_PANEL_TAB_PROGRAM = 'PROGRAM'
 export const ACCESSORY_PANEL_TAB_YOUR = 'YOUR'
-
-// Repetition
-
-export const PROP_MOST_RECENT = 'mostRecent'
-export const PROP_OLDEST = 'oldest'
-
-export const getDefaultCurrentRepetition = () => []
-export const getDefaultUiRepetition = () => ({
-    [PROP_MOST_RECENT]: 1,
-    [PROP_OLDEST]: 0,
-})
-
-export const PARSE_CURRENT_REPETITION_ERROR =
-    'parseCurrentRepetition: Invalid input'
-
-export const PARSE_UI_REPETITION_ERROR = 'parseUiRepetition: Invalid input'
-
-export const parseCurrentRepetition = (repetition) => {
-    if (
-        !(
-            Array.isArray(repetition) &&
-            repetition.every((i) => Number.isFinite(i))
-        )
-    ) {
-        throw new Error(PARSE_CURRENT_REPETITION_ERROR)
-    }
-
-    return repetition.length
-        ? {
-              [PROP_MOST_RECENT]: repetition.filter((n) => n < 1).length,
-              [PROP_OLDEST]: repetition.filter((n) => n > 0).length,
-          }
-        : getDefaultUiRepetition()
-}
-
-export const parseUiRepetition = (repetition) => {
-    if (
-        !(
-            isObject(repetition) &&
-            Number.isFinite(repetition[PROP_MOST_RECENT]) &&
-            repetition[PROP_MOST_RECENT] >= 0 &&
-            Number.isFinite(repetition[PROP_OLDEST]) &&
-            repetition[PROP_OLDEST] >= 0
-        )
-    ) {
-        throw new Error(PARSE_UI_REPETITION_ERROR)
-    }
-
-    // default
-    if (
-        repetition[PROP_OLDEST] === 0 &&
-        [0, 1].includes(repetition[PROP_MOST_RECENT])
-    ) {
-        return getDefaultCurrentRepetition()
-    }
-
-    return [
-        ...new Array(repetition[PROP_OLDEST]).fill().map((_, i) => i + 1),
-        ...new Array(repetition[PROP_MOST_RECENT])
-            .fill()
-            .map((_, i) => -i + 0)
-            .sort((a, b) => a - b),
-    ]
-}
+export const ACCESSORY_PANEL_TAB_TRACKED_ENTITY = 'TRACKED_ENTITY'
diff --git a/src/modules/utils.js b/src/modules/utils.js
index 20b3976ac..662be4676 100644
--- a/src/modules/utils.js
+++ b/src/modules/utils.js
@@ -26,18 +26,3 @@ export const useDidUpdateEffect = (fn, inputs) => {
         }
     }, inputs)
 }
-
-export const formatDimensionId = (dimensionId, programStageId) =>
-    programStageId ? `${programStageId}.${dimensionId}` : dimensionId
-
-export const extractDimensionIdParts = (input) => {
-    const [dimensionId, rawStageId] = input.split('.').reverse()
-    const [programStageId, repetitionIndex] = (rawStageId || '').split('[')
-    return {
-        dimensionId,
-        programStageId,
-        repetitionIndex:
-            repetitionIndex?.length &&
-            repetitionIndex.substring(0, repetitionIndex.indexOf(']')),
-    }
-}
diff --git a/src/modules/visualization.js b/src/modules/visualization.js
index f3153efa8..d6c9e250f 100644
--- a/src/modules/visualization.js
+++ b/src/modules/visualization.js
@@ -33,6 +33,7 @@ export const STATUS_SCHEDULED = 'SCHEDULE'
 
 export const OUTPUT_TYPE_EVENT = 'EVENT'
 export const OUTPUT_TYPE_ENROLLMENT = 'ENROLLMENT'
+export const OUTPUT_TYPE_TRACKED_ENTITY = 'TRACKED_ENTITY_INSTANCE'
 
 export const getStatusNames = () => ({
     [STATUS_ACTIVE]: i18n.t('Active'),
diff --git a/src/reducers/__tests__/ui.spec.js b/src/reducers/__tests__/ui.spec.js
index 5908aafc5..1bf405708 100644
--- a/src/reducers/__tests__/ui.spec.js
+++ b/src/reducers/__tests__/ui.spec.js
@@ -1,4 +1,4 @@
-import { PROP_MOST_RECENT, PROP_OLDEST } from '../../modules/ui.js'
+import { PROP_MOST_RECENT, PROP_OLDEST } from '../../modules/repetition.js'
 import { OUTPUT_TYPE_EVENT } from '../../modules/visualization.js'
 import reducer, {
     DEFAULT_UI,
diff --git a/src/reducers/ui.js b/src/reducers/ui.js
index 9d02c2891..96836ce6f 100644
--- a/src/reducers/ui.js
+++ b/src/reducers/ui.js
@@ -16,6 +16,10 @@ import {
     DIMENSION_ID_EVENT_STATUS,
     DIMENSION_ID_PROGRAM_STATUS,
 } from '../modules/dimensionConstants.js'
+import {
+    formatDimensionId,
+    extractDimensionIdParts,
+} from '../modules/dimensionId.js'
 import { getFilteredLayout } from '../modules/layout.js'
 import { getMainDimensions } from '../modules/mainDimensions.js'
 import { getOptionsForUi } from '../modules/options.js'
@@ -25,15 +29,20 @@ import {
 } from '../modules/programDimensions.js'
 import { getHiddenTimeDimensions } from '../modules/timeDimensions.js'
 import { getAdaptedUiByType, getUiFromVisualization } from '../modules/ui.js'
-import { OUTPUT_TYPE_EVENT } from '../modules/visualization.js'
+import {
+    OUTPUT_TYPE_EVENT,
+    OUTPUT_TYPE_TRACKED_ENTITY,
+} from '../modules/visualization.js'
 import { sGetMetadata, sGetMetadataById } from './metadata.js'
 
 export const SET_UI_DRAGGING_ID = 'SET_UI_DRAGGING_ID'
 export const SET_UI_INPUT = 'SET_UI_INPUT'
 export const CLEAR_UI_PROGRAM = 'CLEAR_UI_PROGRAM'
 export const CLEAR_UI_STAGE_ID = 'CLEAR_UI_STAGE_ID'
+export const CLEAR_UI_ENTITY_TYPE = 'CLEAR_UI_ENTITY_TYPE'
 export const UPDATE_UI_PROGRAM_ID = 'UPDATE_UI_PROGRAM_ID'
 export const UPDATE_UI_PROGRAM_STAGE_ID = 'UPDATE_UI_PROGRAM_STAGE_ID'
+export const UPDATE_UI_ENTITY_TYPE_ID = 'UPDATE_UI_ENTITY_TYPE_ID'
 export const SET_UI_OPTIONS = 'SET_UI_OPTIONS'
 export const ADD_UI_LAYOUT_DIMENSIONS = 'ADD_UI_LAYOUT_DIMENSIONS'
 export const REMOVE_UI_LAYOUT_DIMENSIONS = 'REMOVE_UI_LAYOUT_DIMENSIONS'
@@ -72,6 +81,7 @@ const EMPTY_UI = {
         id: undefined,
         stageId: undefined,
     },
+    entityType: { id: undefined },
     layout: {
         columns: [],
         filters: [],
@@ -90,6 +100,7 @@ export const DEFAULT_UI = {
         type: OUTPUT_TYPE_EVENT,
     },
     program: {},
+    entityType: {},
     layout: {
         // TODO: Populate the layout with the correct default dimensions, these are just temporary for testing
         columns: [DIMENSION_ID_ORGUNIT],
@@ -165,6 +176,12 @@ export default (state = EMPTY_UI, action) => {
                 },
             }
         }
+        case CLEAR_UI_ENTITY_TYPE: {
+            return {
+                ...state,
+                entityType: EMPTY_UI.entityType,
+            }
+        }
         case UPDATE_UI_PROGRAM_ID: {
             return {
                 ...state,
@@ -183,6 +200,15 @@ export default (state = EMPTY_UI, action) => {
                 },
             }
         }
+        case UPDATE_UI_ENTITY_TYPE_ID: {
+            return {
+                ...state,
+                entityType: {
+                    ...state.entityType,
+                    id: action.value,
+                },
+            }
+        }
         case SET_UI_OPTIONS: {
             return {
                 ...state,
@@ -386,6 +412,7 @@ export const sGetUiDraggingId = (state) => sGetUi(state).draggingId
 export const sGetUiType = (state) => sGetUi(state).type
 export const sGetUiInput = (state) => sGetUi(state).input
 export const sGetUiProgram = (state) => sGetUi(state).program
+export const sGetUiEntityType = (state) => sGetUi(state).entityType
 export const sGetUiLayout = (state) => sGetUi(state).layout
 export const sGetUiItems = (state) => sGetUi(state).itemsByDimension
 export const sGetUiOptions = (state) => sGetUi(state).options
@@ -418,6 +445,7 @@ export const sGetUiInputType = (state) => sGetUiInput(state).type
 
 export const sGetUiProgramId = (state) => sGetUiProgram(state).id
 export const sGetUiProgramStageId = (state) => sGetUiProgram(state).stageId
+export const sGetUiEntityTypeId = (state) => sGetUiEntityType(state)?.id
 
 export const sGetUiItemsByDimension = (state, dimension) =>
     sGetUiItems(state)[dimension] ||
@@ -453,7 +481,10 @@ export const renderChipsSelector = createSelector(
 )
 
 // Selector based hooks
-export const useMainDimensions = () => Object.values(getMainDimensions())
+export const useMainDimensions = () => {
+    const inputType = useSelector(sGetUiInputType)
+    return Object.values(getMainDimensions(inputType))
+}
 
 export const useProgramDimensions = () => {
     const { serverVersion } = useConfig()
@@ -462,17 +493,24 @@ export const useProgramDimensions = () => {
     const programId = useSelector(sGetUiProgramId)
     const programStageId = useSelector(sGetUiProgramStageId)
 
+    const getId = (dimensionId) =>
+        formatDimensionId({
+            dimensionId,
+            programId,
+            outputType: inputType,
+        })
+
     const eventDateDim = useSelector((state) =>
-        sGetMetadataById(state, DIMENSION_ID_EVENT_DATE)
+        sGetMetadataById(state, getId(DIMENSION_ID_EVENT_DATE))
     )
     const enrollmentDateDim = useSelector((state) =>
-        sGetMetadataById(state, DIMENSION_ID_ENROLLMENT_DATE)
+        sGetMetadataById(state, getId(DIMENSION_ID_ENROLLMENT_DATE))
     )
     const incidentDateDim = useSelector((state) =>
-        sGetMetadataById(state, DIMENSION_ID_INCIDENT_DATE)
+        sGetMetadataById(state, getId(DIMENSION_ID_INCIDENT_DATE))
     )
     const scheduledDateDim = useSelector((state) =>
-        sGetMetadataById(state, DIMENSION_ID_SCHEDULED_DATE)
+        sGetMetadataById(state, getId(DIMENSION_ID_SCHEDULED_DATE))
     )
 
     return useMemo(() => {
@@ -493,12 +531,22 @@ export const useProgramDimensions = () => {
                 ? [scheduledDateDim]
                 : []),
             incidentDateDim,
-        ].filter(
-            (dimension) =>
-                !!dimension && !hiddenTimeDimensions.includes(dimension.id)
-        )
+        ].filter((dimension) => {
+            if (!dimension) {
+                return false
+            }
+            const { dimensionId } = extractDimensionIdParts(
+                dimension.id,
+                inputType
+            )
+            return !hiddenTimeDimensions.includes(dimensionId)
+        })
 
-        const programDimensions = Object.values(getProgramDimensions()).filter(
+        const programDimensions = Object.values(
+            getProgramDimensions(
+                inputType === OUTPUT_TYPE_TRACKED_ENTITY && programId
+            )
+        ).filter(
             (dimension) =>
                 !getIsProgramDimensionDisabled({
                     dimensionId: dimension.id,
diff --git a/yarn.lock b/yarn.lock
index 7383151f0..e64e7fc13 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -1454,590 +1454,590 @@
     debug "^3.1.0"
     lodash.once "^4.1.1"
 
-"@dhis2-ui/alert@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/alert/-/alert-8.14.5.tgz#a943853898b2903b80dcde0a27940e82a41a2b7d"
-  integrity sha512-B83gUAJJxEy2IGi6H3+jRY6ea7NISIWERDFgezwIxSjvShyEEqhKf0wRHSAil4Rv2a0bBXr43SyVBaMILMXQTA==
+"@dhis2-ui/alert@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/alert/-/alert-9.4.2.tgz#ee57a87449968717d8b80a27dd9769e9f2569e4d"
+  integrity sha512-hSxTDZdEGYurESZMkaK/PmD+gc3U6o+0dChOGmlPgV4r+b4/dKdupd3xXS2lRfXWSmB8Q7xfRPzMXFt5F/KZUg==
   dependencies:
-    "@dhis2-ui/portal" "8.14.5"
+    "@dhis2-ui/portal" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/box@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/box/-/box-8.14.5.tgz#6f86d925e44a7c799232abafcb1c2db036aa6dda"
-  integrity sha512-B+6nGuB2jXM37wzDiSWe5pyyobSSTEwmbgQXA8KuskdRQ16GDszPKXc6QcP04bNhwEB7SNSepNZjPJAORX85Kg==
+"@dhis2-ui/box@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/box/-/box-9.4.2.tgz#bb3b0412bbf55bde396f3166b289f6d4d4897ece"
+  integrity sha512-EvUexG5Gq/VcsOERncR27zDfQYhDy2omGqUXwHu/dTgrIbR9EWSR3fKr0JcpOL/Q37X6K11OQXkRnhlWczlMiQ==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/button@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/button/-/button-8.14.5.tgz#e94fcba1afb74c49ac4b409509bf982a0f4a7adf"
-  integrity sha512-jNzRNctR6qARqRb48MBxDl60Jv6Rk89HDeCgZREnupK5In1ZGegG1tl294tfxBhTSq0/ROEXNxevfNlTqQBq+g==
+"@dhis2-ui/button@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/button/-/button-9.4.2.tgz#81283e4f096e9eedd4f164680cc6781c6330369b"
+  integrity sha512-PaaglsIbnReHWrkwa4iUQoDv6ILC2lUkPf+S1davDZjlYXx+LF9TJXaZpjlRaq+RO8yI4bUaxyHlJGxAihMOpw==
   dependencies:
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/calendar@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/calendar/-/calendar-8.14.5.tgz#5e65ff92d98266f952034b73039d6336211c16f1"
-  integrity sha512-4+OZDmlIoEvvuNzXJUBaqoLgbl1pKWaNIHpn0bpl8uJggnl5eO/SaKGowANnOXbmrL5AD/2sqyz83hCaazrZAg==
+"@dhis2-ui/calendar@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/calendar/-/calendar-9.4.2.tgz#3a57fcc89747af8ba1457703dbe565a175052d07"
+  integrity sha512-XyME946EnTcLxqU6Y1zii9gLNbmYSA0taKpjBHj9arhzslly5J2fpRUkMrkEEnrhl9oq7fErKRYO3qdmk/XyRA==
   dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
     "@dhis2/multi-calendar-dates" "1.0.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/card@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/card/-/card-8.14.5.tgz#127239b35a7388ced44a3b413723887061dc940f"
-  integrity sha512-YTwlYvE/BXyL7XILrGdRveBzy/51lwsK6Tb1QGQoZ6X7kchcrA6bCKwPlNwOiaz6g8QcDvG/xnfnBuGI0BD8rw==
+"@dhis2-ui/card@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/card/-/card-9.4.2.tgz#e43f85396a50b4e662fede310458ff2c5d4e54d9"
+  integrity sha512-r1tzyuoXIx48+scA3hIkilpkICOBTDCoYkeapy2OC6e/MvQff0fj5Xa4Xk/vG2LDeIG7VhrkrtOtxWBR70rIOw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/center@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/center/-/center-8.14.5.tgz#050660cdd710813350a71bda773413870e4bdbed"
-  integrity sha512-BxOUMs52F/0xctxU57U1tVh+anHcAIsjmmJ3re8B1NnXP8kzYWI2FP88+BoC3v6qD1pobOkFx/Qr3xofJPIRAA==
+"@dhis2-ui/center@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/center/-/center-9.4.2.tgz#c90980ed112b0271cfe9cb8de69add04da2999c5"
+  integrity sha512-SPOv4lOZD020rNs8gYGqf8eGSthaf8gZuE3HVFAJNaJm08jrrihj6jH0wEGWvK/zkrbu5gSTvDZ0hkdFdiTLEg==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/checkbox@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/checkbox/-/checkbox-8.14.5.tgz#cd555482b21176563fae70344b70223eb3128729"
-  integrity sha512-AKd60wmGQY/wANB77y6jYfceMGmAGu73zHoQYAyKdw3B4noaTqeuvjfQf1C7qJA+ofF0XizKB7jXq6y5YTpZHQ==
+"@dhis2-ui/checkbox@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/checkbox/-/checkbox-9.4.2.tgz#2eb6387d72d20610e0104fd0aa4bec8842c71ca9"
+  integrity sha512-NW0xbHYjCq/b+h5+BlZap8ptEUSeh1sBjr9pY1vXe/A64ZDmRmX960nUiC3Kd/te6T77gY3oOuabaxNPMqsZ7g==
   dependencies:
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/required" "8.14.5"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/required" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/chip@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/chip/-/chip-8.14.5.tgz#e86253fb19721a13ae2ced30cfa5d24b223929ac"
-  integrity sha512-wXpdrJX5Jtth5ISujeesRchbP7tKio3Oq8m7Ekwad8550dXiKj04u1I4qSD+Pxemutr4czZQBmkwY9fQfd5dCQ==
+"@dhis2-ui/chip@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/chip/-/chip-9.4.2.tgz#bd10fc0096836c063b2e78235799ea9129a351ad"
+  integrity sha512-a9oWmeb5fkcNHeHDCCMGcOIq5CBbssbvPRHDGfJ0E6+gkBS81Tp1IDG/gSs4c9/rEDiunTCx7/P11BbDc3hQVA==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/cover@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/cover/-/cover-8.14.5.tgz#4b848d9ba4fedf3142d2ad05e5746f7b42662b6c"
-  integrity sha512-QuuktAZON7f24Kxb62vCElKkStqzhTvR+TlHDenw9QfT4uoKa0AugIJsqdc11z3UgRahtIZEN8XuNIjK8dNVrQ==
+"@dhis2-ui/cover@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/cover/-/cover-9.4.2.tgz#8582c2115d8db9e9231c17093f6a808eb142394d"
+  integrity sha512-jd/7iOXwpf81lBgb9r+O08jFDO6D7dfUrKTuMtZn9k0NPITFh4enbDvB3BOuUOJIJ7/jY6Ynr5QPjkbWyTazmw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/css@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/css/-/css-8.14.5.tgz#26a79357f874497f408ea2f2d7cb31b6cf68bd9d"
-  integrity sha512-7SZPHvI3dDszHhixrFVoueWSAfYJgBYeBbDSPlaaWUWtTY3QX3fpw5j2PMjp94xGLvJXDdvJLj6m6uP9ofFoeg==
+"@dhis2-ui/css@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/css/-/css-9.4.2.tgz#144143f1430e5788f64cbbb250b9bc6b27f17ea1"
+  integrity sha512-Eu2V/ByPJWucrW0hw59tcQIcUrd8aZ4cJcVW6/qubPzox1Em1N8H63RtPLkgj6IZhrn15g9k84ku8RHMXLAsSw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/divider@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/divider/-/divider-8.14.5.tgz#59f8151aa290e28d12664d65eb8cbfb6d227b982"
-  integrity sha512-KEl62QO/T7kANphyqFaad3vXPTASiGKK+vTY4UE9gd94JzicqBeqDgQDLjZyOpT5OGL2ad9dwY5667WkPT0i2w==
+"@dhis2-ui/divider@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/divider/-/divider-9.4.2.tgz#b694635e053cbed1e01621e3feb57b9e2a1548ee"
+  integrity sha512-nbHPlu993UEIJE9ZWhTVBtuuB9StRC3aEAvbT4UM8Pq3rGHeIRN6NKhK9QVkNUxpv0Spcub7T8V6SZVDk7TRgg==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/field@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/field/-/field-8.14.5.tgz#f50b928e51c2e4919f12f90c47da22be8bcc80a6"
-  integrity sha512-wl0E8BKf/7oLHgPjpMegj/udnqjA36GgKaHWZ9h/1YKRAoYJoh+4N6nsOzyJwOMnfJ53nBd2pKbIMn8H5jWP6Q==
+"@dhis2-ui/field@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/field/-/field-9.4.2.tgz#917e463d6e9e4203a815fad13cd919818f52383f"
+  integrity sha512-2OV+MLLnVLZBOYZTQuoK+9G2AktZwMR09S8dkIzgQAhjspoTGZ0u8p9Q9aBDuN9FbVTVqslZe3ssB3SJ6y178A==
   dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/help" "8.14.5"
-    "@dhis2-ui/label" "8.14.5"
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/help" "9.4.2"
+    "@dhis2-ui/label" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/file-input@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/file-input/-/file-input-8.14.5.tgz#930f8f14d03f33412aa433da0f8754251b5eb58e"
-  integrity sha512-jutdpB8lM4iGPGDtAwR+2s/onXUAgoHXgvTy6cEQE5A0BFMfFphVJ0kdQMab9GYCH1/ufdAKdwjFtBM4tJjymg==
+"@dhis2-ui/file-input@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/file-input/-/file-input-9.4.2.tgz#3e6bd2a38a328413f77066e451b63189b28b58cc"
+  integrity sha512-QKpLbd9rxVqAunsaNqdMrkdo0VOil/UznfFd+mqYIlb1mzoRVF9EQinvs7GVdN1f+2JHpGTTRpIYkWwyM7NETQ==
   dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/label" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/status-icon" "8.14.5"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/label" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/status-icon" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/header-bar@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/header-bar/-/header-bar-8.14.5.tgz#34dc19cec5eff6e720cc1d1e17e919ed2c6188f9"
-  integrity sha512-yiOREw+ZITGPFoR5ohalzSNNYz0BILEpo2J8KsRGJWgCTYhB1Pt2m68sOLEhLD1bvO6oVHmvxSP4binpoLv31A==
-  dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/center" "8.14.5"
-    "@dhis2-ui/divider" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/logo" "8.14.5"
-    "@dhis2-ui/menu" "8.14.5"
-    "@dhis2-ui/modal" "8.14.5"
-    "@dhis2-ui/user-avatar" "8.14.5"
+"@dhis2-ui/header-bar@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/header-bar/-/header-bar-9.4.2.tgz#d1031a751db43bd5d10b37714b4e9578556b7576"
+  integrity sha512-PGtjJZppch4K8SdyE0nUEl9Zae+svYn1qmJtVONbhB1xdL/ae/V/GcLr8XVDmRRrk4x0wlgn8zITU6I6pF4cYg==
+  dependencies:
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/center" "9.4.2"
+    "@dhis2-ui/divider" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/logo" "9.4.2"
+    "@dhis2-ui/menu" "9.4.2"
+    "@dhis2-ui/modal" "9.4.2"
+    "@dhis2-ui/user-avatar" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     moment "^2.29.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/help@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/help/-/help-8.14.5.tgz#6d05d94624ac19436ec3dc244db93cc8118f671c"
-  integrity sha512-4fX+jKXOn56YdaHwW5HWIN6HcXGUajlOJsZY73JA4eh2Bg6aiUAyNhJe7s0/6W0wl0k4PS0dvDi52emd1irtMQ==
+"@dhis2-ui/help@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/help/-/help-9.4.2.tgz#1fdfd62fbd4c2fff39e0306ac4374c1178454413"
+  integrity sha512-l8F/YdrNL5F7GnDpqs+3FJ4ZbDckSux9+5hANO6dXKT60QZINkDchxBr5KtYnApoe/JuyF3+0g84hCZnd8mI/A==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/input@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/input/-/input-8.14.5.tgz#82371e5b5eb4c8aed6040eeb631fddb06e08be43"
-  integrity sha512-BiQK6W+JIBm98oEMuoml7J4VdBgZb7P4oJVyrTQEUOXJvuZS1JZg9YFF4BFoPymRr5TremZ56LDxmPT3ShOWIA==
+"@dhis2-ui/input@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/input/-/input-9.4.2.tgz#d8d2810c97efe654e96266bb02b0745709c2182b"
+  integrity sha512-s/lYVTMlqjzawQdD6GOTzCiqrDkIp/asrSD8iOzM6gwD53OSEZa0HQhIBBW+y4YfW5i09/BExJGi4C9VQ0PpFQ==
   dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/status-icon" "8.14.5"
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/status-icon" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/intersection-detector@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/intersection-detector/-/intersection-detector-8.14.5.tgz#53fb6fd4c0e45f135f4e32da72996f334ce3638f"
-  integrity sha512-pU51aBU0kkAyadItHG2sDAWyhbQVXBqUjjpNdwewu2yWmGDbpOoa+TACxl27fJshUTboAw5Xs5AQt3HR4832iA==
+"@dhis2-ui/intersection-detector@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/intersection-detector/-/intersection-detector-9.4.2.tgz#8562692539dad5c6bfb4a9ec0df53646d3480e68"
+  integrity sha512-YblS3MuibJrYyLl4nnT4eQ3NZi8RZ85bnKp87ldp8h6BcvoRvJWW5IJR7gjNqq/iT0ckVhRKBZaldMsY9PI/ZQ==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/label@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/label/-/label-8.14.5.tgz#5018d677623f209b78c09010ee81c69df8441ed4"
-  integrity sha512-Td2VfFo9P8rDwv9PxwsIPZZrYpvRbWeN0UCxX/U/+HOSz3th0HuV8KuG9N9ITwXDmq0RXHRRUpcD+FIC88JnkA==
+"@dhis2-ui/label@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/label/-/label-9.4.2.tgz#0a046eb4cb23f90a22d2e1ad3483c37e6b06e700"
+  integrity sha512-Rs4igunIpX1D92LHlIobFj/wthsmAV43hAi4tT+xyhEcruSArCKRPBk2iYyyVLyxPbvOYw7ebl6E9ahrhRIS5w==
   dependencies:
-    "@dhis2-ui/required" "8.14.5"
+    "@dhis2-ui/required" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/layer@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/layer/-/layer-8.14.5.tgz#b83d325162036200a21f06a69d04d1ce44953991"
-  integrity sha512-8MEQwSBNc/GjtfnvMD2ELMvoAw54Bv7IkQ75ifpmciPlo2N00bSTwB+wWApvr6bbZ1elsNjWd72saPzNZceJ/w==
+"@dhis2-ui/layer@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/layer/-/layer-9.4.2.tgz#339d9c89a4f496b52f9329f3f501e9d24de32c77"
+  integrity sha512-6YSmz6dJ0fhYWsy3GUmBJacXblUGQo+wbxRdEzmJcdyTJVcz9AeY4JhHaGu+DPRMe3360B8D0oOXKl4g+0SqpQ==
   dependencies:
-    "@dhis2-ui/portal" "8.14.5"
+    "@dhis2-ui/portal" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/legend@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/legend/-/legend-8.14.5.tgz#a7545da6b0c567e7080508ac1e8b45227d9a6ebf"
-  integrity sha512-ATT18B7JAUIecyEdKuiFhiZevnhMmtFK/NVq/FdDyq+7I5gl1uGZ5S/ePFFUEreuZEHmyGoVRtjhlb/a/rdjZg==
+"@dhis2-ui/legend@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/legend/-/legend-9.4.2.tgz#98b69c79b483e79aeb6f2c1b8d218d90c3053e1a"
+  integrity sha512-qqd7/zN4+/67Xmr9toW/+ah61uRVo18FACUwozHgKSldd4R0wePApAqYcaVyZ+n8XiiPHZcJIU1A2x6OCjP4sw==
   dependencies:
-    "@dhis2-ui/required" "8.14.5"
+    "@dhis2-ui/required" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/loader@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/loader/-/loader-8.14.5.tgz#1da467dcebf5e5f095a43b0839f1decb8b709279"
-  integrity sha512-8S7iomHlhLVSPJ4TsJoI2sC9eXrxz94ZHsRtVg8zFXuL0AtQAk0L/2WgDJlfVkj/fwwmhF/2qkcC01lOtwT/ZA==
+"@dhis2-ui/loader@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/loader/-/loader-9.4.2.tgz#58f4bacb39c520d7b9f0af4876ba35639cad3aae"
+  integrity sha512-OPrtGNzR5wJpwXs4i8ylyhiyNky2/mgjhaq7YF86DUDiiuyIDAwYH0WttipdgKMo50SIsXDCu0McrM7s9eNGnA==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/logo@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/logo/-/logo-8.14.5.tgz#5605b1f7ceb101126aa63de3b0fcc0ab17dba5ed"
-  integrity sha512-OGUE2jxASFYJ2/hl5gv+zPWmOoxgzT9yYxbhF9vMi33qdALTIFlDnCqMaLkDIZMmjPl3tnJ+etLQaHyCP+T3aw==
+"@dhis2-ui/logo@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/logo/-/logo-9.4.2.tgz#13cf228e18df04726dde66b0ec0a467e30246a66"
+  integrity sha512-Fpru8TkDS644PPtBzCz0GLZZpQsFRxZ50lAyR489fAnUCA6MC87Sux58z3/VfUv0himSpqMYGd46QFbsGou0+g==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/menu@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/menu/-/menu-8.14.5.tgz#fc2ada6c1a16d393c329879f947cb706d3d6f9bf"
-  integrity sha512-V2Uw/1Yn0IZya5lh2erZJWHV8M3Y0VbApieDckmrd+WtLRbUA7dbC4ZGeT3eDdWP8H7GWbXKzxoFM3ENja5p5Q==
+"@dhis2-ui/menu@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/menu/-/menu-9.4.2.tgz#bbf8f4ecbc9abadf0742a9e04ba03d1b34730881"
+  integrity sha512-bPXXEkm1+l/NL1KHZ4+y0xrJxLZcKl6ynrJcIe2paPtmkvb/0lVJqbrX6bycddHsQga6WVB7oHiDoYGoaKusrw==
   dependencies:
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/divider" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2-ui/portal" "8.14.5"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/divider" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2-ui/portal" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/modal@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/modal/-/modal-8.14.5.tgz#6c6d4243a4e76949a3480109ae1c269579ade149"
-  integrity sha512-MA7NKcbhw95np7P5If3wHFFA4Mv1xKXV8LwWDUmlTKBBJvLemNHWbF48UsWWhJ/zAhLJxU+nqK7pXpZ38CRJgQ==
+"@dhis2-ui/modal@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/modal/-/modal-9.4.2.tgz#db952f15cdcfd5c40c45f9dde268c948c6315352"
+  integrity sha512-u0fF7uVS0twk1QJsv6hcUfjk6BXKSaA74vyYGkR5wWxXMbHUJLqgk+DHjUstBvK+u4oYJXwFiJKA6bGKee9Dug==
   dependencies:
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/center" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/portal" "8.14.5"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/center" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/portal" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/node@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/node/-/node-8.14.5.tgz#f9bfbc9bc10372d017fc705ae49cdd9d7e326449"
-  integrity sha512-xY/l+IGi/r+56IdRPqyxaSxUweD1zd1zZ1t47mILsvPbPC21P7QY+iNS+UGZ7jQwFDdP6CtQkb1y4PSniANPyA==
+"@dhis2-ui/node@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/node/-/node-9.4.2.tgz#4837b983e8c7cb138d73d74c25bcbde377d7aaad"
+  integrity sha512-5bUTZdYJcGOsx8x1IPWm1hou3zlbBq46vC1ignh8OdrFdZf8u7/e2ZOe8GpN9m/BcRAnl4AOvQe7dQ9u3t+g6g==
   dependencies:
-    "@dhis2-ui/loader" "8.14.5"
+    "@dhis2-ui/loader" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/notice-box@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/notice-box/-/notice-box-8.14.5.tgz#8492392d06485d1a95874fd83c254cdfa23fec62"
-  integrity sha512-df8PhmRShZ+tckBWwkj+j3Go2vYmh6bXrh6IkDpMTR18SI6PmthTidEO0qzTHAaCY3gIW3gue93taSrQc/Cm7w==
+"@dhis2-ui/notice-box@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/notice-box/-/notice-box-9.4.2.tgz#de05d2fbeb983e7e09189857e6639a973068848e"
+  integrity sha512-skoUUbti/v4pe3VIJRh+ealWSyIu+vrdjtrRuO/tn39zkZ2JKOgzfYazUPisyaI5uVjup3+3wlAnRkf8vy6jIw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/organisation-unit-tree@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/organisation-unit-tree/-/organisation-unit-tree-8.14.5.tgz#57d21b8ae7ab28f7d22b0ad4ea28aa0a0c02afb2"
-  integrity sha512-82QMk7Qcp0tQpQ1chSj+w9lcwWuvuE+0yyRvY2Lv0HN7P4WF/OQAfktJSuG8FkyKzHs74JGgcr1C00RnRlBvrg==
+"@dhis2-ui/organisation-unit-tree@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/organisation-unit-tree/-/organisation-unit-tree-9.4.2.tgz#9208b700db840587ed2891421d377e811e1a2c35"
+  integrity sha512-XTaWcE3caiEt6Ucbm8ekB0cMypTt3w3/VXozVc3a9OcgvoID3cGKuXWDrTgBsUaTZxKEBhNn/hkR6o36JHxF9Q==
   dependencies:
-    "@dhis2-ui/checkbox" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/node" "8.14.5"
+    "@dhis2-ui/checkbox" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/node" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/pagination@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/pagination/-/pagination-8.14.5.tgz#c0a59dfe49c192a8ef17d6778e149ba7bb7d4aa3"
-  integrity sha512-tjAGzkZ7JhCzQsLSCQ5kptdEdB8zvOE7w39ndc6dfd6MIQumZIbk1PxIhBU4zH0EjEFOPris5k/1CK61nX8LXQ==
+"@dhis2-ui/pagination@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/pagination/-/pagination-9.4.2.tgz#24d372fdf765c1761fb46a3a97dba3652e4ccc4b"
+  integrity sha512-bMcAWmW3+bpWI4TY70k4C+CmTObhhJ296nsCMK1shecNkBT52X9SnfPq1azpgth8SQjfOk2nJ80dQPBJ9Clu2g==
   dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/select" "8.14.5"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/select" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/popover@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/popover/-/popover-8.14.5.tgz#403982edfa403108b8eaab6204b8bf21e1253160"
-  integrity sha512-vLFWuLbw5hlUc+WI1M9Vla3FQ2CyZqVlxK7yCxIEuT9VqFaltuexpDGOxAXll6AyvUwBeWiFt20o/GHqSQBndQ==
+"@dhis2-ui/popover@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/popover/-/popover-9.4.2.tgz#4a4dc93b1c1c46b6afa34a2750a938ada9cecde0"
+  integrity sha512-1xHnFuIMTl7FzYr12jeQPEF5KgV9c8kXj3XgwfPEkzPjnSy3WzSklnSYAswRJIJqsEDR5cclQ6X+y+hFHSgh2Q==
   dependencies:
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/popper@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/popper/-/popper-8.14.5.tgz#060633aa69101a58a309c15c748cff7aad826dd1"
-  integrity sha512-xL8eHsk05ZzF1xkZc4YeAhD4QM7Bqd0koFbVhZcj3RFO2UTP100xS2G0g21ASM6IqObCudrpG8ytnZr1SCmRzg==
+"@dhis2-ui/popper@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/popper/-/popper-9.4.2.tgz#eac5b0d695f067892a8e8259243f306a9cf85e3c"
+  integrity sha512-8me9hxXs6GXpqC/8nzsuDtqtl8VmuIVss4idVLy/tLCqEKbxV8Hll0+3YLhJiWzUAIZ6YgTO2OzHcVVGE61nWw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     "@popperjs/core" "^2.10.1"
     classnames "^2.3.1"
     prop-types "^15.7.2"
     react-popper "^2.2.5"
     resize-observer-polyfill "^1.5.1"
 
-"@dhis2-ui/portal@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/portal/-/portal-8.14.5.tgz#57e80547065d2a42871ddcbdf881f4939aba8990"
-  integrity sha512-bWrqPneQJwFjMnvlWrWrOJTqcV3siUzkEhxQUoYqHHw/KUT44WDJ0GXOMKoWSH/w0xbr8AzY4i1nU34rkcGVew==
+"@dhis2-ui/portal@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/portal/-/portal-9.4.2.tgz#276578538e7452caabfb960bcdf400c4b4b06858"
+  integrity sha512-2565A++jWOIxCA7Ozu5Fi3OKWyBKh/bFldDSmiwODhVuQisUhH64OUAyPm21xX84oXWaPCGGWI3NQt9zj4o+gA==
   dependencies:
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/radio@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/radio/-/radio-8.14.5.tgz#4ea5e31e3f1607ae409e8d9e159aa05d381dd2d5"
-  integrity sha512-6MdZNYBx4K3H7DVlOPclSmtIhHaJDB9GLWoxVBmcNTzl4F0CYJKepT6BIu9qkbvRbv2jWeKahMp4XL847BAQgg==
+"@dhis2-ui/radio@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/radio/-/radio-9.4.2.tgz#d359749b4b26cd06c2b0fa150dc0402e7bab4545"
+  integrity sha512-DNS5XrVcyDU8fQq5G5/Y2tclaqTxT1cKuhbxxlZaBbYc/r1vn+9Zlsh/+zZmGDHQKBK3rlFOfDPiuenIhDhdmg==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/required@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/required/-/required-8.14.5.tgz#7982483b22f47dd6e91473b86c14ddee61c29300"
-  integrity sha512-mnZ7sigc6uJciB3C1PMLRiCTAWVpw9JH1Oq+SYWg8ZsFRuBRDIwdRk6Cl9/3gAiY/FIyWKaIw7U7ThRXo/c0mA==
+"@dhis2-ui/required@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/required/-/required-9.4.2.tgz#80635f94959af93106efdce780f0ad0d9143ffa2"
+  integrity sha512-MEx9GKZwhLwh1WQX/HwCj8nnEH+GOUAr/PdrLWTMpbD8/b0iKdRyq+2tCNyMy29mUKCkCZUMWLc0VZxE5ng6iw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/segmented-control@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/segmented-control/-/segmented-control-8.14.5.tgz#6a78de5f0b9c98b792fb3e07e82c70ea8a1a9335"
-  integrity sha512-KxuLwztlRHe0+K/ky+zcGBzTE1S6UGoGxNxZumQcnRjm6aoTGtYC35jvBaMoFozyLmKq/QXDcl+rJegq4RX8Iw==
+"@dhis2-ui/segmented-control@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/segmented-control/-/segmented-control-9.4.2.tgz#e446ef61bfa67bc983852d5cfa2f26ae9a6fa04b"
+  integrity sha512-rFmuHpnnsL7EGDGoOLkhU9DcdEfUP4f+W0X/ynze5Kh9R8IsE2ryxQE7OEMRIPe6BhNuS++BBl+3OXb2z1/pHw==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/select@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/select/-/select-8.14.5.tgz#ce8eb3a2b920365277a0ce664579632b18d5f9a4"
-  integrity sha512-MsoNKAAOfeTPr9wMxL1vQcvfvssJm7srLmtihukGT8h8vMJg9EZkMTvMgAgRF7IhSSjTcW5vO/zAByTAyiFZSg==
-  dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/checkbox" "8.14.5"
-    "@dhis2-ui/chip" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2-ui/status-icon" "8.14.5"
+"@dhis2-ui/select@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/select/-/select-9.4.2.tgz#f286e0b40e7a1f0a089781abcee35241caa1769e"
+  integrity sha512-SKlvddAP+tleOkQ6W7yGYsBYWBpfbeCHfKvGRD/0Jp9ZBTHRi7OOopdTpmqY111xbvabLcxP3NkZtDuTFd6pCw==
+  dependencies:
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/checkbox" "9.4.2"
+    "@dhis2-ui/chip" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2-ui/status-icon" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/selector-bar@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/selector-bar/-/selector-bar-8.14.5.tgz#6b70bc632a147ca54e7c5adc052075142e4edf1a"
-  integrity sha512-7lkhZYLlHZH1yrTVaoQ/i1Hz/12xnp0gEbSPsevhZWMQ455lVcLMGIaVc3oRewRvYAS4SZtfH/vE6+QsFBcPCA==
-  dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+"@dhis2-ui/selector-bar@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/selector-bar/-/selector-bar-9.4.2.tgz#301ad4df292cf840015fbe082cef9b1c1403abf2"
+  integrity sha512-+0HSAyu08pjnmwL9ORxxJGNvzMEi1neiSS3wUY55fkXJL2RrJuuPWeRVgz3ZrKuA152XxqV20c0esl9p5dxY0A==
+  dependencies:
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     "@testing-library/react" "^12.1.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/sharing-dialog@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/sharing-dialog/-/sharing-dialog-8.14.5.tgz#5cc2a4b41c89653bfa995ed7495ebf7a6e360751"
-  integrity sha512-fxU8QkpQwoJJJN71Gx6x96qyi8G2rLTNZWpsF3rc3KJ+ZS9tFO8rr7l3LDc5R6L8MRsgy/wLxthl2LF0fp/4YA==
-  dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/divider" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/menu" "8.14.5"
-    "@dhis2-ui/modal" "8.14.5"
-    "@dhis2-ui/notice-box" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2-ui/select" "8.14.5"
-    "@dhis2-ui/tab" "8.14.5"
-    "@dhis2-ui/tooltip" "8.14.5"
-    "@dhis2-ui/user-avatar" "8.14.5"
+"@dhis2-ui/sharing-dialog@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/sharing-dialog/-/sharing-dialog-9.4.2.tgz#6895b4c6d91869ffb0073389d2aba38fd2fe1977"
+  integrity sha512-cGppvbtIMMY0XGHbYt9PozpWIoPamFMHUPIvyW2hVgbl2j7+wD/d05pquII2W+alGBRoN5iIfCLQpZ11RDaJtA==
+  dependencies:
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/divider" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/menu" "9.4.2"
+    "@dhis2-ui/modal" "9.4.2"
+    "@dhis2-ui/notice-box" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2-ui/select" "9.4.2"
+    "@dhis2-ui/tab" "9.4.2"
+    "@dhis2-ui/tooltip" "9.4.2"
+    "@dhis2-ui/user-avatar" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     "@react-hook/size" "^2.1.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/status-icon@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/status-icon/-/status-icon-8.14.5.tgz#204d50ad2595845203f63c2423d6cf58ad0a1b5e"
-  integrity sha512-miqIfH0J1+KMChqeNoxkqiOm2vAOLXp8qMRJPTB60DZN2FaytiBZA7kUHf8XYFodbO+LbnIHa9VtYHt1POmKBA==
+"@dhis2-ui/status-icon@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/status-icon/-/status-icon-9.4.2.tgz#3c5589d03eead01e3c57e3767061460370e13793"
+  integrity sha512-zPUdRjzQIgw300qRFREg/NJvAP/a/eE8ptxmMPORlUBKpArYz8IPRo3vKLOgRK4xGUBqqSeINneE3YfsEUCvQA==
   dependencies:
-    "@dhis2-ui/loader" "8.14.5"
+    "@dhis2-ui/loader" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/switch@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/switch/-/switch-8.14.5.tgz#5163940f49ac9008c6b631c2f554a0184b06a2e4"
-  integrity sha512-ybRhRZEUltQ9CLLsIPmUNh4Rhjxde/rd3o1hiDJ3chGMrPT/19bYZ5wwQ8rfJEb5f/6d9vqtmLdwfOKIUNCsTA==
+"@dhis2-ui/switch@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/switch/-/switch-9.4.2.tgz#aeca03394a6792783f67fa71048610019b95895d"
+  integrity sha512-CWLxQv1YmPtqQtJHtkl/GPWXsuppe+g3qLjlduXRoJtA9d5RNPOQzEHonFSxZtDQwkEKLt+8U1T/DPjHx07T0g==
   dependencies:
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/required" "8.14.5"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/required" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/tab@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/tab/-/tab-8.14.5.tgz#e86e0a8d8e20df7869e237b23e488c285680e0c4"
-  integrity sha512-0qOt9LcG2bcvcQRaw5OnsVHl9q6GQh9jMwzwXt4I/v4uCS6dh4u/ntNBfA3Kkg1TNqipSe1dmjCP/ma28RyK8g==
+"@dhis2-ui/tab@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/tab/-/tab-9.4.2.tgz#131c7b3f4c19e1e7e8cf5f20cde5fd679996d243"
+  integrity sha512-+cGst+ZLXogqEqO+Zkx1Sr7vusFReE3EBYVFMDS72Vj2Vlvp5Z71YuP+BpL+8Llal+2M/zGCUUjpFSKHQgW9Pg==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/table@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/table/-/table-8.14.5.tgz#333e8ab4a66f6be1b4bf4107e95f64f9a4cb9840"
-  integrity sha512-MFwR1BgwWIhvxwXEK4nC8cE5Tc6kS1Veo+0TqdsyBS/3SX8kCSgbg29i/Rl9DedD34GWAUQyBsyH6RrWX8x+7Q==
+"@dhis2-ui/table@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/table/-/table-9.4.2.tgz#50c30871aa0add89135c0bc3dbb531c0144143da"
+  integrity sha512-G8c7yZ8Y5d+EeBKE1nMWNkSJhhhB/a9XeShn+L9LruEkYw9FACl9zHxjPJG5t3A097Leld+LWB2+uouRUzVWRQ==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/tag@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/tag/-/tag-8.14.5.tgz#45a98f2c6a8b7466af6b9a5f9655dcfa37eb0848"
-  integrity sha512-cOWVjSM8wjoXCg74ZrnCjhOA/PBkGKiuu2RaDco9WFb0y4R73SljqVL4zuijxytc3BaxOltvBJOb0nLjKiW5Ww==
+"@dhis2-ui/tag@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/tag/-/tag-9.4.2.tgz#fbf86c106856c76c1126181d9a41da5793acb052"
+  integrity sha512-X8BIY3fd1+scwB2c9vFGl6AiLwS8L+UYKs0NqutYBI++1EHHfDO4GZbkyb5A96By31OdpA/qo7EebDk0X1ZJyg==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/text-area@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/text-area/-/text-area-8.14.5.tgz#810601b373a3cece802823489c8db619817b9768"
-  integrity sha512-pDBTxQ5ZfDYvjTfgsqkAk8EpjtaID2jiJ1DF9GE+zlB74GE0Mjof5ZgwDaBjvlmT+Cg3EJjBw4eHhuZlw7PNag==
+"@dhis2-ui/text-area@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/text-area/-/text-area-9.4.2.tgz#dc58e1a59ab561a856baf8fb687901b4478b230e"
+  integrity sha512-8D9mF/WuGAyjs5LQ5esyltiyUE0yuMWGuf7907TdV6QmgB3jN0xF3bECo/Xqhtc8wHR2jiq94YjF3XPmj9WSHQ==
   dependencies:
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/status-icon" "8.14.5"
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/status-icon" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/tooltip@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/tooltip/-/tooltip-8.14.5.tgz#97128332d953feca90115093885fb0780861c16c"
-  integrity sha512-iGDXLXP6HsJBN7DpStsvc0z0vL8gJZ8NbFuZ5UNcGJDcRkzWSwmFFWyEszFryoUMEQVBADpgL5cdzfsqsNUtyA==
+"@dhis2-ui/tooltip@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/tooltip/-/tooltip-9.4.2.tgz#a84442a7eb0e863eff968d837261f6783150eb50"
+  integrity sha512-sSZ8c+0MEA7tiSCPtuc5LpNCvglPjO/oSCKkAeqiBN1ofKAzzyPAaHUNDiKWZIMyQtvNItUIzTIUGVhjHNLMcA==
   dependencies:
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2-ui/portal" "8.14.5"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2-ui/portal" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/transfer@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/transfer/-/transfer-8.14.5.tgz#926a7ca75d2dc75f97328ace46eccaa9698ef3ec"
-  integrity sha512-K69/68JreNqQV+ROBtGPuRFeN0bXoiiIcyodTYI7HEMxqs3JnvALhQFAZAzJxhhNpXksq3dAegGNucFFxThWWw==
+"@dhis2-ui/transfer@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/transfer/-/transfer-9.4.2.tgz#a7c6b055809088e3023239da5e6c93b77c180a7d"
+  integrity sha512-w+jMJU34hGdDr120JclmKEXYUA7Ea/vQ1qURftJDf4HzH9n2Avk6Qv+X8nWd9v0Y3gza4o0L46jr9r0HkSnSbQ==
   dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/intersection-detector" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/intersection-detector" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2-ui/user-avatar@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2-ui/user-avatar/-/user-avatar-8.14.5.tgz#8f02f6eb0440d80c4ab6fc4505972b4c3557a8e8"
-  integrity sha512-hDjJZL0P8YUC+8kS9JXL/CZcaai3rWYGsz8ee11F+Uh943qFKw6/kb13egt3zQnTsCyvJWqz+eB7DguxlNbHtQ==
+"@dhis2-ui/user-avatar@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2-ui/user-avatar/-/user-avatar-9.4.2.tgz#cb71a1e90b102ba432d2509cacc4ac052f88f385"
+  integrity sha512-WBRDBQfqq2C2w9tGZMrBya5GO8GiQTov1ajK4S3mTgIT+HnbwNaLpWSRTcU/4oI5leupWTBmRf3CsSniemNyeA==
   dependencies:
     "@dhis2/prop-types" "^3.1.2"
-    "@dhis2/ui-constants" "8.14.5"
+    "@dhis2/ui-constants" "9.4.2"
     classnames "^2.3.1"
     prop-types "^15.7.2"
 
-"@dhis2/analytics@^26.3.0":
-  version "26.3.0"
-  resolved "https://registry.yarnpkg.com/@dhis2/analytics/-/analytics-26.3.0.tgz#ada2fe27442f19704fa704e334546416c85ea1d6"
-  integrity sha512-B/pUh8K8wyivL4yBiwqPoQ94pMWwCqh0xu3Uak4jmJqS+jO0slUlyDLtAmXU/jqRlRgRg1nR4u18npjd511Q7A==
+"@dhis2/analytics@^26.6.0":
+  version "26.6.0"
+  resolved "https://registry.yarnpkg.com/@dhis2/analytics/-/analytics-26.6.0.tgz#1d70463fca8a4d5f5838928e9ab6c5c07873715f"
+  integrity sha512-fO8ozVfnTulXQptPcT3W/y+Ru6sN/Qjhr6dWHL4LsG2siL1v8QOWKcnM/yScClJtRZvsbEnQ6vX47c7ujRsGUA==
   dependencies:
     "@dhis2/d2-ui-rich-text" "^7.4.1"
     "@dhis2/multi-calendar-dates" "1.0.0"
@@ -2272,91 +2272,91 @@
     workbox-routing "^6.1.5"
     workbox-strategies "^6.1.5"
 
-"@dhis2/ui-constants@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2/ui-constants/-/ui-constants-8.14.5.tgz#68da92906855a6a1d4f1fdc74e5d96deb4d97679"
-  integrity sha512-azmg85q6RiD3tfaXMXEkWD1BevVUOgKPY1wBU7Dnw4Cq1m35YOoGkxEuCGxjpXUNvOuWWxmFJqO7xK1lqnN6iw==
+"@dhis2/ui-constants@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2/ui-constants/-/ui-constants-9.4.2.tgz#a6a0d4e862c3fca9eb78e0c23b0fc969d580c6ad"
+  integrity sha512-yvFO1F00uXl9a37wZTDC1sqlcjSQ7uZVVtOLa0oRi79sR+U5IAx1rzdIDWY+lpleRNNznkZsiINWp6jn/Ag7UQ==
   dependencies:
     prop-types "^15.7.2"
 
-"@dhis2/ui-forms@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2/ui-forms/-/ui-forms-8.14.5.tgz#2774bbf759019d284a71be3ac0133f90da5ffedd"
-  integrity sha512-yy+zflkgUb2WDH5czyl3z3wFePulbz3ECrKIBUP+lqRCh5D0Cg4t455uaDiXeBlUhIIuauRk/q7h2VoJ7cuZZg==
-  dependencies:
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/checkbox" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/file-input" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/radio" "8.14.5"
-    "@dhis2-ui/select" "8.14.5"
-    "@dhis2-ui/switch" "8.14.5"
-    "@dhis2-ui/text-area" "8.14.5"
+"@dhis2/ui-forms@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2/ui-forms/-/ui-forms-9.4.2.tgz#8d4b7c43ecb45faa460d0811ac7fb362d1d3c979"
+  integrity sha512-QLRWLQSNki0HGPHvd0wWlevhDuN42COh/fA/XTwHx0Gf3xb6BrI9Gkuhyh3cJvTnUOUpCA6jviyIoj6T/JLTgQ==
+  dependencies:
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/checkbox" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/file-input" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/radio" "9.4.2"
+    "@dhis2-ui/select" "9.4.2"
+    "@dhis2-ui/switch" "9.4.2"
+    "@dhis2-ui/text-area" "9.4.2"
     "@dhis2/prop-types" "^3.1.2"
     classnames "^2.3.1"
     final-form "^4.20.2"
     prop-types "^15.7.2"
     react-final-form "^6.5.3"
 
-"@dhis2/ui-icons@8.14.5":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2/ui-icons/-/ui-icons-8.14.5.tgz#0e2efd2d8c055f40cbe08133b7f447b63daac786"
-  integrity sha512-PeXvoBqr68ZF7cjvMHq6Shqti8zQG1RtBJS/22h8MRCcSg5/5oHtbdedu+/51pe6kIKULRHFU1qj58a9l87O+A==
-
-"@dhis2/ui@^8.12.3", "@dhis2/ui@^8.14.5", "@dhis2/ui@^8.3.1":
-  version "8.14.5"
-  resolved "https://registry.yarnpkg.com/@dhis2/ui/-/ui-8.14.5.tgz#ad5ede5db832aa5c121aec1531d0b7549fae983e"
-  integrity sha512-DMF6m2PED7XeWvHdGzu8w2MBin8nw22mtCCfLpy6CAHUPcukSNGuFD/a5nT5n+sXvA22Bl+qgl211cREAPV42Q==
-  dependencies:
-    "@dhis2-ui/alert" "8.14.5"
-    "@dhis2-ui/box" "8.14.5"
-    "@dhis2-ui/button" "8.14.5"
-    "@dhis2-ui/calendar" "8.14.5"
-    "@dhis2-ui/card" "8.14.5"
-    "@dhis2-ui/center" "8.14.5"
-    "@dhis2-ui/checkbox" "8.14.5"
-    "@dhis2-ui/chip" "8.14.5"
-    "@dhis2-ui/cover" "8.14.5"
-    "@dhis2-ui/css" "8.14.5"
-    "@dhis2-ui/divider" "8.14.5"
-    "@dhis2-ui/field" "8.14.5"
-    "@dhis2-ui/file-input" "8.14.5"
-    "@dhis2-ui/header-bar" "8.14.5"
-    "@dhis2-ui/help" "8.14.5"
-    "@dhis2-ui/input" "8.14.5"
-    "@dhis2-ui/intersection-detector" "8.14.5"
-    "@dhis2-ui/label" "8.14.5"
-    "@dhis2-ui/layer" "8.14.5"
-    "@dhis2-ui/legend" "8.14.5"
-    "@dhis2-ui/loader" "8.14.5"
-    "@dhis2-ui/logo" "8.14.5"
-    "@dhis2-ui/menu" "8.14.5"
-    "@dhis2-ui/modal" "8.14.5"
-    "@dhis2-ui/node" "8.14.5"
-    "@dhis2-ui/notice-box" "8.14.5"
-    "@dhis2-ui/organisation-unit-tree" "8.14.5"
-    "@dhis2-ui/pagination" "8.14.5"
-    "@dhis2-ui/popover" "8.14.5"
-    "@dhis2-ui/popper" "8.14.5"
-    "@dhis2-ui/portal" "8.14.5"
-    "@dhis2-ui/radio" "8.14.5"
-    "@dhis2-ui/required" "8.14.5"
-    "@dhis2-ui/segmented-control" "8.14.5"
-    "@dhis2-ui/select" "8.14.5"
-    "@dhis2-ui/selector-bar" "8.14.5"
-    "@dhis2-ui/sharing-dialog" "8.14.5"
-    "@dhis2-ui/switch" "8.14.5"
-    "@dhis2-ui/tab" "8.14.5"
-    "@dhis2-ui/table" "8.14.5"
-    "@dhis2-ui/tag" "8.14.5"
-    "@dhis2-ui/text-area" "8.14.5"
-    "@dhis2-ui/tooltip" "8.14.5"
-    "@dhis2-ui/transfer" "8.14.5"
-    "@dhis2-ui/user-avatar" "8.14.5"
-    "@dhis2/ui-constants" "8.14.5"
-    "@dhis2/ui-forms" "8.14.5"
-    "@dhis2/ui-icons" "8.14.5"
+"@dhis2/ui-icons@9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2/ui-icons/-/ui-icons-9.4.2.tgz#b2e069534945eb05ef627dd3a54b0583beb717e1"
+  integrity sha512-ZLBHlxEQmwdOfoYNbpx4MohNP/V/0Y3aucIywVXMvAZne0qPjkjq7es8OZMmacdMNIKhyJjCpT6IqjwoYgLQUw==
+
+"@dhis2/ui@^8.12.3", "@dhis2/ui@^9.4.2":
+  version "9.4.2"
+  resolved "https://registry.yarnpkg.com/@dhis2/ui/-/ui-9.4.2.tgz#85aeaa5da1d558c882d9588d6b7a917396548ac9"
+  integrity sha512-dvFEK11kzYx29rkDDRk49lpGpqB9bEf4WEO9eSsw/7bK/GaS/uiS7ca8c30R+tdUmjvubBNxJiVJI07EwxtHyw==
+  dependencies:
+    "@dhis2-ui/alert" "9.4.2"
+    "@dhis2-ui/box" "9.4.2"
+    "@dhis2-ui/button" "9.4.2"
+    "@dhis2-ui/calendar" "9.4.2"
+    "@dhis2-ui/card" "9.4.2"
+    "@dhis2-ui/center" "9.4.2"
+    "@dhis2-ui/checkbox" "9.4.2"
+    "@dhis2-ui/chip" "9.4.2"
+    "@dhis2-ui/cover" "9.4.2"
+    "@dhis2-ui/css" "9.4.2"
+    "@dhis2-ui/divider" "9.4.2"
+    "@dhis2-ui/field" "9.4.2"
+    "@dhis2-ui/file-input" "9.4.2"
+    "@dhis2-ui/header-bar" "9.4.2"
+    "@dhis2-ui/help" "9.4.2"
+    "@dhis2-ui/input" "9.4.2"
+    "@dhis2-ui/intersection-detector" "9.4.2"
+    "@dhis2-ui/label" "9.4.2"
+    "@dhis2-ui/layer" "9.4.2"
+    "@dhis2-ui/legend" "9.4.2"
+    "@dhis2-ui/loader" "9.4.2"
+    "@dhis2-ui/logo" "9.4.2"
+    "@dhis2-ui/menu" "9.4.2"
+    "@dhis2-ui/modal" "9.4.2"
+    "@dhis2-ui/node" "9.4.2"
+    "@dhis2-ui/notice-box" "9.4.2"
+    "@dhis2-ui/organisation-unit-tree" "9.4.2"
+    "@dhis2-ui/pagination" "9.4.2"
+    "@dhis2-ui/popover" "9.4.2"
+    "@dhis2-ui/popper" "9.4.2"
+    "@dhis2-ui/portal" "9.4.2"
+    "@dhis2-ui/radio" "9.4.2"
+    "@dhis2-ui/required" "9.4.2"
+    "@dhis2-ui/segmented-control" "9.4.2"
+    "@dhis2-ui/select" "9.4.2"
+    "@dhis2-ui/selector-bar" "9.4.2"
+    "@dhis2-ui/sharing-dialog" "9.4.2"
+    "@dhis2-ui/switch" "9.4.2"
+    "@dhis2-ui/tab" "9.4.2"
+    "@dhis2-ui/table" "9.4.2"
+    "@dhis2-ui/tag" "9.4.2"
+    "@dhis2-ui/text-area" "9.4.2"
+    "@dhis2-ui/tooltip" "9.4.2"
+    "@dhis2-ui/transfer" "9.4.2"
+    "@dhis2-ui/user-avatar" "9.4.2"
+    "@dhis2/ui-constants" "9.4.2"
+    "@dhis2/ui-forms" "9.4.2"
+    "@dhis2/ui-icons" "9.4.2"
     prop-types "^15.7.2"
 
 "@dnd-kit/accessibility@^3.0.0":