diff --git a/core/api/core.api b/core/api/core.api
index bf5b7adf46..dcbf911126 100644
--- a/core/api/core.api
+++ b/core/api/core.api
@@ -1714,6 +1714,10 @@ public final class org/jetbrains/kotlinx/dataframe/api/CountDistinctKt {
 	public static final fun countDistinct (Lorg/jetbrains/kotlinx/dataframe/DataFrame;[Ljava/lang/String;)I
 	public static final fun countDistinct (Lorg/jetbrains/kotlinx/dataframe/DataFrame;[Lkotlin/reflect/KProperty;)I
 	public static final fun countDistinct (Lorg/jetbrains/kotlinx/dataframe/DataFrame;[Lorg/jetbrains/kotlinx/dataframe/columns/ColumnReference;)I
+	public static final fun countDistinct (Lorg/jetbrains/kotlinx/dataframe/api/Grouped;Ljava/lang/String;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
+	public static final fun countDistinct (Lorg/jetbrains/kotlinx/dataframe/api/Grouped;Ljava/lang/String;Lkotlin/jvm/functions/Function2;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
+	public static synthetic fun countDistinct$default (Lorg/jetbrains/kotlinx/dataframe/api/Grouped;Ljava/lang/String;ILjava/lang/Object;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
+	public static synthetic fun countDistinct$default (Lorg/jetbrains/kotlinx/dataframe/api/Grouped;Ljava/lang/String;Lkotlin/jvm/functions/Function2;ILjava/lang/Object;)Lorg/jetbrains/kotlinx/dataframe/DataFrame;
 }
 
 public final class org/jetbrains/kotlinx/dataframe/api/CountKt {
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
index f3c407c3ee..99dcdd7f90 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -4,10 +4,18 @@ import org.jetbrains.kotlinx.dataframe.AnyColumnReference
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.annotations.AccessApiOverload
+import org.jetbrains.kotlinx.dataframe.annotations.Interpretable
+import org.jetbrains.kotlinx.dataframe.annotations.Refine
+import org.jetbrains.kotlinx.dataframe.api.CountDistinctOnGroupByDocs.COLUMNS_PARAM
+import org.jetbrains.kotlinx.dataframe.api.CountDistinctOnGroupByDocs.COLUMN_SELECTION_DSL
+import org.jetbrains.kotlinx.dataframe.api.CountDistinctOnGroupByDocs.COMPARISON_OBJECT
+import org.jetbrains.kotlinx.dataframe.api.CountDistinctOnGroupByDocs.EXAMPLE
+import org.jetbrains.kotlinx.dataframe.api.CountDistinctOnGroupByDocs.SCOPE
 import org.jetbrains.kotlinx.dataframe.columns.toColumnSet
 import org.jetbrains.kotlinx.dataframe.documentation.DocumentationUrls
 import org.jetbrains.kotlinx.dataframe.documentation.ExcludeFromSources
 import org.jetbrains.kotlinx.dataframe.documentation.SelectingColumns
+import org.jetbrains.kotlinx.dataframe.impl.aggregation.modes.aggregateValue
 import org.jetbrains.kotlinx.dataframe.indices
 import org.jetbrains.kotlinx.dataframe.util.DEPRECATED_ACCESS_API
 import kotlin.reflect.KProperty
@@ -93,3 +101,81 @@ public fun <T> DataFrame<T>.countDistinct(vararg columns: AnyColumnReference): I
     countDistinct { columns.toColumnSet() }
 
 // endregion
+
+// region GroupBy
+
+/**
+ * Aggregates this [GroupBy] by counting the number of distinct {@get [COMPARISON_OBJECT] rows} in each group.
+ *
+ * Compares rows in each group based on the values in {@get [SCOPE] all} columns.
+ * Returns a new [DataFrame] where each row corresponds to a group.
+ * The resulting [DataFrame] contains:
+ * - the original group key columns,
+ * - a new column (named [resultName\], default is `"countDistinct"`)
+ * that contains the number of distinct {@get [COMPARISON_OBJECT] rows} in each group.
+ *
+ * See also:
+ * - [aggregate][Grouped.aggregate], which aggregates a [GroupBy] using the provided statistics.
+ * - [count][Grouped.count], which counts the number of rows in each group.
+ * - [distinct][DataFrame.distinct], which removes duplicate rows and returns a new [DataFrame].
+ * - [groupBy][DataFrame.groupBy], which groups the rows of a [DataFrame]
+ * based on the values in one or more specified cols.
+ *
+ * For more information: {@include [DocumentationUrls.CountDistinct]}
+ *
+ * {@get [COLUMN_SELECTION_DSL]}
+ *
+ * ### Example
+ * ```kotlin
+ * {@get [EXAMPLE]}
+ * ```
+ *
+ * @param [resultName\] The name of the result column that will store the number
+ * of distinct {@get [COMPARISON_OBJECT] rows} in each group. Defaults to `"countDistinct"`.
+ * @get [COLUMNS_PARAM]
+ * @return A new [DataFrame] with group keys and corresponding numbers of distinct {@get [COMPARISON_OBJECT] rows}.
+ */
+@ExcludeFromSources
+private interface CountDistinctOnGroupByDocs {
+    typealias COMPARISON_OBJECT = Nothing
+    typealias SCOPE = Nothing
+    typealias EXAMPLE = Nothing
+    typealias COLUMN_SELECTION_DSL = Nothing
+    typealias COLUMNS_PARAM = Nothing
+}
+
+/**
+ * @include [CountDistinctOnGroupByDocs]
+ * @set [EXAMPLE]
+ * // Counts the number of distinct rows for each city, returning
+ * // a new DataFrame with columns "city" and "countDistinct"
+ * df.groupBy { city }.countDistinct()
+ */
+@Refine
+@Interpretable("GroupByCountDistinct0")
+public fun <T> Grouped<T>.countDistinct(resultName: String = "countDistinct"): DataFrame<T> =
+    countDistinct(resultName) { all() }
+
+/**
+ * @include [CountDistinctOnGroupByDocs]
+ * @set [COMPARISON_OBJECT] combinations of values in the selected [columns]
+ * @set [SCOPE] the selected
+ * @set [COLUMN_SELECTION_DSL] {@include [SelectingColumns.ColumnsSelectionDsl]}
+ * @set [EXAMPLE]
+ * // Counts unique combinations of values in the "year" and "title" columns
+ * // for each city, returning a new DataFrame with columns "city" and "countDistinct"
+ * df.groupBy { city }.countDistinct { year and title }
+ * @set [COLUMNS_PARAM] @param [columns\] The [ColumnsSelector] used to select columns
+ * that will be considered for evaluating whether the rows are distinct.
+ */
+@Refine
+@Interpretable("GroupByCountDistinct0")
+public fun <T, C> Grouped<T>.countDistinct(
+    resultName: String = "countDistinct",
+    columns: ColumnsSelector<T, C>,
+): DataFrame<T> =
+    aggregateValue(resultName) {
+        countDistinct(columns) default 0
+    }
+
+// endregion
diff --git a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
index 32c1c5bf81..0b1a9a2da2 100644
--- a/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
+++ b/core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/api/groupBy.kt
@@ -156,6 +156,9 @@ internal interface GroupByDocs {
      * `| `__`.`__[**`count`**][Grouped.count]**`() `**
      *
      * {@include [Indent]}
+     * `| `__`.`__[**`countDistinct`**][Grouped.countDistinct]**`() `**
+     *
+     * {@include [Indent]}
      * `| `__`.`__[**`aggregate`**][Grouped.aggregate]**`  {  `**`aggregations: `[`AggregateDsl`][AggregateDsl]**` }`**
      *
      * {@include [Indent]}
@@ -196,6 +199,8 @@ internal interface GroupByDocs {
      *
      * * [count][Grouped.count] — calculate the number of rows in each group
      *   (optionally counting only rows that satisfy the given predicate);
+     * * [`countDistinct`][Grouped.countDistinct] — calculate the number of distinct rows in each group
+     *   (or distinct combinations of values in selected columns);
      * * [max][Grouped.max] / [maxOf][Grouped.maxOf] / [maxFor][Grouped.maxFor] —
      *   calculate the maximum of all values on the selected columns / by a row expression /
      *   for each of the selected columns within each group;
@@ -301,6 +306,8 @@ internal interface GroupByDocs {
      *   from all rows of each group for the selected columns.
      * * [count][Grouped.count] — creates a [DataFrame] containing the grouping key columns and an additional column
      *   with the number of rows in each corresponding group;
+     * * [countDistinct][Grouped.countDistinct] — creates a [DataFrame] containing the grouping key columns
+     *   and an additional column with the number of distinct rows in each corresponding group;
      * * [aggregate][Grouped.aggregate] — performs a set of custom aggregations using [AggregateDsl],
      *   allowing you to compute one or more derived values per group;
      * * [Various aggregation statistics][AggregationStatistics] — predefined shortcuts
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
new file mode 100644
index 0000000000..0e0810c9ee
--- /dev/null
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/countDistinct.kt
@@ -0,0 +1,146 @@
+package org.jetbrains.kotlinx.dataframe.api
+
+import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.nrow
+import org.junit.Test
+
+class CountDistinctTests {
+
+    private val df = dataFrameOf(
+        "name" to columnOf("Alice", "Alice", "Bob", "Charlie"),
+        "age" to columnOf(15, 15, 20, 25),
+        "group" to columnOf(1, 1, 1, 2),
+    )
+
+    @Test
+    fun `countDistinct on GroupBy`() {
+        val result = df.groupBy("group").countDistinct()
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(2, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with custom result name`() {
+        val result = df.groupBy("group").countDistinct("unique")
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "unique" to columnOf(2, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with one unique row`() {
+        val df = dataFrameOf(
+            "name" to columnOf("Alice", "Alice", "Alice"),
+            "age" to columnOf(15, 15, 15),
+            "group" to columnOf(1, 1, 1),
+        )
+        val result = df.groupBy("group").countDistinct()
+        val expected = dataFrameOf(
+            "group" to columnOf(1),
+            "countDistinct" to columnOf(1),
+        )
+        result shouldBe expected
+    }
+
+    // TODO: check columns as well when #1531 is fixed
+    @Test
+    fun `countDistinct on empty GroupBy`() {
+        df
+            .drop(df.nrow)
+            .groupBy("group").countDistinct()
+            .count() shouldBe 0
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with nulls`() {
+        val result = df
+            .append(null, null, 1)
+            .groupBy("group").countDistinct()
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(3, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with null group key`() {
+        val result = df
+            .append("Dave", 30, null)
+            .groupBy("group").countDistinct()
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2, null),
+            "countDistinct" to columnOf(2, 1, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with columns selector`() {
+        val result = df.groupBy("group").countDistinct { "name"<String>() }
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(2, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with columns selector (not distinct only by selected column)`() {
+        val df = dataFrameOf(
+            "name" to columnOf("Alice", "Bob", "Charlie"),
+            "age" to columnOf(15, 15, 20),
+            "group" to columnOf(1, 1, 2),
+        )
+        val result = df.groupBy("group").countDistinct { "age"<Int>() }
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(1, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on GroupBy with multiple columns selector`() {
+        val df = dataFrameOf(
+            "name" to columnOf("Alice", "Alice", "Bob", "Charlie"),
+            "age" to columnOf(15, 15, 20, 25),
+            "group" to columnOf(1, 1, 1, 2),
+            "city" to columnOf("London", "Moscow", "London", "Paris"),
+        )
+        val result = df.groupBy("group").countDistinct { "name"<String>() and "age"<Int>() }
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(2, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on grouped DataFrame with columns selector and custom result name`() {
+        val result = df.groupBy("group").countDistinct(resultName = "unique") { "name"<String>() }
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "unique" to columnOf(2, 1),
+        )
+        result shouldBe expected
+    }
+
+    @Test
+    fun `countDistinct on grouped DataFrame with multiple columns selector with nulls`() {
+        val result = df
+            .append(null, null, 1)
+            .groupBy("group")
+            .countDistinct { "name"<String>() and "age"<Int>() }
+        val expected = dataFrameOf(
+            "group" to columnOf(1, 2),
+            "countDistinct" to columnOf(3, 1),
+        )
+        result shouldBe expected
+    }
+}
diff --git a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
index 9b4ecf5bfc..e8afdc8450 100644
--- a/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
+++ b/core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/Access.kt
@@ -6,7 +6,6 @@ import org.jetbrains.kotlinx.dataframe.api.add
 import org.jetbrains.kotlinx.dataframe.api.after
 import org.jetbrains.kotlinx.dataframe.api.chunked
 import org.jetbrains.kotlinx.dataframe.api.colsOf
-import org.jetbrains.kotlinx.dataframe.api.countDistinct
 import org.jetbrains.kotlinx.dataframe.api.distinct
 import org.jetbrains.kotlinx.dataframe.api.distinctBy
 import org.jetbrains.kotlinx.dataframe.api.drop
@@ -431,30 +430,6 @@ class Access : TestBase() {
         // SampleEnd
     }
 
-    @Test
-    @TransformDataFrameExpressions
-    fun countDistinct() {
-        // SampleStart
-        df.countDistinct()
-        // SampleEnd
-    }
-
-    @Test
-    @TransformDataFrameExpressions
-    fun countDistinctColumns_properties() {
-        // SampleStart
-        df.countDistinct { age and name }
-        // SampleEnd
-    }
-
-    @Test
-    @TransformDataFrameExpressions
-    fun countDistinctColumns_strings() {
-        // SampleStart
-        df.countDistinct("age", "name")
-        // SampleEnd
-    }
-
     @Test
     @TransformDataFrameExpressions
     fun distinctColumns_strings() {
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsCustomNameOnGroupBy_properties.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsCustomNameOnGroupBy_properties.html
new file mode 100644
index 0000000000..22abe47ddc
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsCustomNameOnGroupBy_properties.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow"] }, 
+{ name: "<span title=\"uniqueFirstNames: Int\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">uniqueFirstNames</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsDf.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsDf.html
new file mode 100644
index 0000000000..8a2594d162
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsDf.html
@@ -0,0 +1,516 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Bob"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Charlie"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Charlie"}] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Cooper"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Dylan"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Daniels"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Byrd"}] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"}] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"}] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "London"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Dubai"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Moscow"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Moscow"}] }, 
+{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"}] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"},{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "false"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"}] }, 
+], id: 0, rootId: 0, totalRows: 4 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsGroupBy.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsGroupBy.html
new file mode 100644
index 0000000000..ba884df876
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsGroupBy.html
@@ -0,0 +1,574 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow"] }, 
+{ name: "<span title=\"group: api.FormattedFrame<org.jetbrains.kotlinx.dataframe.samples.api.`CountDistinctSamples$countDistinctColumnsGroupBy$2$Group_891`>\">group</span>", children: [], rightAlign: false, values: [{ frameId: 1, value: "<b>DataFrame 1 x 5</b>" },{ frameId: 2, value: "<b>DataFrame 1 x 5</b>" },{ frameId: 3, value: "<b>DataFrame 2 x 5</b>" }] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Alice"}] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Cooper"}] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>"}] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"}] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "London"}] }, 
+{ name: "<span title=\"weight: Int\">weight</span>", children: [], rightAlign: true, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>"}] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: [{ style: "background-color:#bdcee9;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"}] }, 
+], id: 1, rootId: 0, totalRows: 1 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Bob"}] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Dylan"}] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>"}] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>"}] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Dubai"}] }, 
+{ name: "<span title=\"weight: Int\">weight</span>", children: [], rightAlign: true, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>"}] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: [{ style: "background-color:#c6e0c6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"}] }, 
+], id: 2, rootId: 0, totalRows: 1 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Charlie"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Charlie"}] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Daniels"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Byrd"}] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"}] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"}] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Moscow"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "Moscow"}] }, 
+{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"}] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: [{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "false"},{ style: "background-color:#dbc6e6;color:#000000;--text-color:#000000 !important;--text-color-dark:#000000 !important;--text-color-pale:#000000 !important;--text-color-medium:#000000 !important", value: "true"}] }, 
+], id: 3, rootId: 0, totalRows: 2 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+(function () {
+    function expandColumnGroups(df) {
+        for (let col of df.cols) {
+            if (col.parent === undefined && col.children.length > 0) col.expanded = true;
+        }
+    }
+
+    function expandNestedFrames(df, rootDf) {
+        for (let col of df.cols) {
+            for (let value of col.values) {
+                if (value && value.frameId !== undefined) {
+                    rootDf.expandedFrames.add(value.frameId);
+                    let child = rootDf.childFrames[value.frameId];
+                    if (child) {
+                        expandColumnGroups(child);
+                        expandNestedFrames(child, rootDf);
+                    }
+                }
+            }
+        }
+    }
+
+    document.querySelectorAll("table.dataframe").forEach(function (table) {
+        if (table.df && table.df.id === table.df.rootId) {
+            let rootDf = table.df;
+            expandNestedFrames(rootDf, rootDf);
+            DataFrame.renderTable(rootDf.id);
+        }
+    });
+})();
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsOnGroupBy_properties.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsOnGroupBy_properties.html
new file mode 100644
index 0000000000..33f67fa573
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctColumnsOnGroupBy_properties.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow"] }, 
+{ name: "<span title=\"countDistinct: Int\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">countDistinct</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctDf.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctDf.html
new file mode 100644
index 0000000000..402c557208
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctDf.html
@@ -0,0 +1,516 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Alice","Bob","Charlie","Charlie"] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Cooper","Dylan","Daniels","Byrd"] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow","Moscow"] }, 
+{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["true","true","false","true"] }, 
+], id: 0, rootId: 0, totalRows: 4 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctGroupBy.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctGroupBy.html
new file mode 100644
index 0000000000..f26cbd0bc9
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctGroupBy.html
@@ -0,0 +1,574 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow"] }, 
+{ name: "<span title=\"group: DataFrame<*>\">group</span>", children: [], rightAlign: false, values: [{ frameId: 1, value: "<b>DataFrame 1 x 5</b>" },{ frameId: 2, value: "<b>DataFrame 1 x 5</b>" },{ frameId: 3, value: "<b>DataFrame 2 x 5</b>" }] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Alice"] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Cooper"] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Alice\nlastName: Cooper\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Alice<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Cooper<span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">15</span></span>"] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London"] }, 
+{ name: "<span title=\"weight: Int\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">54</span></span>"] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["true"] }, 
+], id: 1, rootId: 0, totalRows: 1 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Bob"] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Dylan"] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Bob\nlastName: Dylan\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Bob<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dylan<span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">45</span></span>"] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["Dubai"] }, 
+{ name: "<span title=\"weight: Int\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">87</span></span>"] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["true"] }, 
+], id: 2, rootId: 0, totalRows: 1 } ) });
+/*-->*/
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"firstName: String\">firstName</span>", children: [], rightAlign: false, values: ["Charlie","Charlie"] }, 
+{ name: "<span title=\"lastName: String\">lastName</span>", children: [], rightAlign: false, values: ["Daniels","Byrd"] }, 
+{ name: "<span title=\"name: DataRow<*>\">name</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Daniels\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Dan<span class=\"structural\">...</span><span class=\"structural\"> }</span></span>","<span class=\"formatted\" title=\"firstName: Charlie\nlastName: Byrd\"><span class=\"structural\">{ </span><span class=\"structural\">firstName: </span>Charlie<span class=\"structural\">, </span><span class=\"structural\">lastName: </span>Byrd<span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"age: Int\">age</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">20</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">30</span></span>"] }, 
+{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["Moscow","Moscow"] }, 
+{ name: "<span title=\"weight: Int?\">weight</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">90</span></span>"] }, 
+{ name: "<span title=\"isHappy: Boolean\">isHappy</span>", children: [], rightAlign: false, values: ["false","true"] }, 
+], id: 3, rootId: 0, totalRows: 2 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+(function () {
+    function expandColumnGroups(df) {
+        for (let col of df.cols) {
+            if (col.parent === undefined && col.children.length > 0) col.expanded = true;
+        }
+    }
+
+    function expandNestedFrames(df, rootDf) {
+        for (let col of df.cols) {
+            for (let value of col.values) {
+                if (value && value.frameId !== undefined) {
+                    rootDf.expandedFrames.add(value.frameId);
+                    let child = rootDf.childFrames[value.frameId];
+                    if (child) {
+                        expandColumnGroups(child);
+                        expandNestedFrames(child, rootDf);
+                    }
+                }
+            }
+        }
+    }
+
+    document.querySelectorAll("table.dataframe").forEach(function (table) {
+        if (table.df && table.df.id === table.df.rootId) {
+            let rootDf = table.df;
+            expandNestedFrames(rootDf, rootDf);
+            DataFrame.renderTable(rootDf.id);
+        }
+    });
+})();
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/countDistinct/countDistinctOnGroupBySmallTable_properties.html b/docs/StardustDocs/resources/api/countDistinct/countDistinctOnGroupBySmallTable_properties.html
new file mode 100644
index 0000000000..f84d1e8140
--- /dev/null
+++ b/docs/StardustDocs/resources/api/countDistinct/countDistinctOnGroupBySmallTable_properties.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow"] }, 
+{ name: "<span title=\"countDistinct: Int\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">countDistinct</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 3 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/groupBy/countDistinctOnGroupBy_properties.html b/docs/StardustDocs/resources/api/groupBy/countDistinctOnGroupBy_properties.html
new file mode 100644
index 0000000000..d8e535cdb1
--- /dev/null
+++ b/docs/StardustDocs/resources/api/groupBy/countDistinctOnGroupBy_properties.html
@@ -0,0 +1,511 @@
+<html>
+<head>
+<style type="text/css">
+:root {
+    --background: #fff;
+    --background-odd: #f5f5f5;
+    --background-hover: #d9edfd;
+    --header-text-color: #474747;
+    --text-color: #848484;
+    --text-color-dark: #000;
+    --text-color-medium: #737373;
+    --text-color-pale: #b3b3b3;
+    --inner-border-color: #aaa;
+    --bold-border-color: #000;
+    --link-color: #296eaa;
+    --link-color-pale: #296eaa;
+    --link-hover: #1a466c;
+}
+
+:root[theme="dark"], :root [data-jp-theme-light="false"], .dataframe_dark{
+    --background: #303030;
+    --background-odd: #3c3c3c;
+    --background-hover: #464646;
+    --header-text-color: #dddddd;
+    --text-color: #b3b3b3;
+    --text-color-dark: #dddddd;
+    --text-color-medium: #b2b2b2;
+    --text-color-pale: #737373;
+    --inner-border-color: #707070;
+    --bold-border-color: #777777;
+    --link-color: #008dc0;
+    --link-color-pale: #97e1fb;
+    --link-hover: #00688e;
+}
+
+p.dataframe_description {
+    color: var(--text-color-dark);
+}
+
+table.dataframe {
+    font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+    font-size: 12px;
+    background-color: var(--background);
+    color: var(--text-color-dark);
+    border: none;
+    border-collapse: collapse;
+}
+
+table.dataframe th, td {
+    padding: 6px;
+    border: 1px solid transparent;
+    text-align: left;
+}
+
+table.dataframe th {
+    background-color: var(--background);
+    color: var(--header-text-color);
+}
+
+table.dataframe td {
+    vertical-align: top;
+    white-space: nowrap;
+}
+
+table.dataframe th.bottomBorder {
+    border-bottom-color: var(--bold-border-color);
+}
+
+table.dataframe tbody > tr:nth-child(odd) {
+    background: var(--background-odd);
+}
+
+table.dataframe tbody > tr:nth-child(even) {
+    background: var(--background);
+}
+
+table.dataframe tbody > tr:hover {
+    background: var(--background-hover);
+}
+
+table.dataframe a {
+    cursor: pointer;
+    color: var(--link-color);
+    text-decoration: none;
+}
+
+table.dataframe tr:hover > td a {
+    color: var(--link-color-pale);
+}
+
+table.dataframe a:hover {
+    color: var(--link-hover);
+    text-decoration: underline;
+}
+
+table.dataframe img {
+    max-width: fit-content;
+}
+
+table.dataframe th.complex {
+    background-color: var(--background);
+    border: 1px solid var(--background);
+}
+
+table.dataframe .leftBorder {
+    border-left-color: var(--inner-border-color);
+}
+
+table.dataframe .rightBorder {
+    border-right-color: var(--inner-border-color);
+}
+
+table.dataframe .rightAlign {
+    text-align: right;
+}
+
+table.dataframe .expanderSvg {
+    width: 8px;
+    height: 8px;
+    margin-right: 3px;
+}
+
+table.dataframe .expander {
+    display: flex;
+    align-items: center;
+}
+
+/* formatting */
+
+table.dataframe .null {
+    color: var(--text-color-pale);
+}
+
+table.dataframe .structural {
+    color: var(--text-color-medium);
+    font-weight: bold;
+}
+
+table.dataframe .dataFrameCaption {
+    font-weight: bold;
+}
+
+table.dataframe .numbers {
+    color: var(--text-color-dark);
+}
+
+table.dataframe td:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+table.dataframe tr:hover .formatted .structural, .null {
+    color: var(--text-color-dark);
+}
+
+
+body {
+    font-family: "JetBrains Mono",SFMono-Regular,Consolas,"Liberation Mono",Menlo,Courier,monospace;
+}       
+
+:root {
+    color: #19191C;
+    background-color: #fff;
+}
+
+:root[theme="dark"] {
+    background-color: #19191C;
+    color: #FFFFFFCC
+}
+
+details details {
+    margin-left: 20px; 
+}
+
+summary {
+    padding: 6px;
+}
+</style>
+</head>
+<body>
+<table class="dataframe" id="df_0"></table>
+
+<p class="dataframe_description"></p>
+</body>
+<script>
+(function () {
+    window.DataFrame = window.DataFrame || new (function () {
+        this.addTable = function (df) {
+            let cols = df.cols;
+            for (let i = 0; i < cols.length; i++) {
+                for (let c of cols[i].children) {
+                    cols[c].parent = i;
+                }
+            }
+            df.nrow = 0
+            for (let i = 0; i < df.cols.length; i++) {
+                if (df.cols[i].values.length > df.nrow) df.nrow = df.cols[i].values.length
+            }
+            if (df.id === df.rootId) {
+                df.expandedFrames = new Set()
+                df.childFrames = {}
+                const table = this.getTableElement(df.id)
+                table.df = df
+                for (let i = 0; i < df.cols.length; i++) {
+                    let col = df.cols[i]
+                    if (col.parent === undefined && col.children.length > 0) col.expanded = true
+                }
+            } else {
+                const rootDf = this.getTableData(df.rootId)
+                rootDf.childFrames[df.id] = df
+            }
+        }
+
+        this.computeRenderData = function (df) {
+            let result = []
+            let pos = 0
+            for (let col = 0; col < df.cols.length; col++) {
+                if (df.cols[col].parent === undefined)
+                    pos += this.computeRenderDataRec(df.cols, col, pos, 0, result, false, false)
+            }
+            for (let i = 0; i < result.length; i++) {
+                let row = result[i]
+                for (let j = 0; j < row.length; j++) {
+                    let cell = row[j]
+                    if (j === 0)
+                        cell.leftBd = false
+                    if (j < row.length - 1) {
+                        let nextData = row[j + 1]
+                        if (nextData.leftBd) cell.rightBd = true
+                        else if (cell.rightBd) nextData.leftBd = true
+                    } else cell.rightBd = false
+                }
+            }
+            return result
+        }
+
+        this.computeRenderDataRec = function (cols, colId, pos, depth, result, leftBorder, rightBorder) {
+            if (result.length === depth) {
+                const array = [];
+                if (pos > 0) {
+                    let j = 0
+                    for (let i = 0; j < pos; i++) {
+                        let c = result[depth - 1][i]
+                        j += c.span
+                        let copy = Object.assign({empty: true}, c)
+                        array.push(copy)
+                    }
+                }
+                result.push(array)
+            }
+            const col = cols[colId];
+            let size = 0;
+            if (col.expanded) {
+                let childPos = pos
+                for (let i = 0; i < col.children.length; i++) {
+                    let child = col.children[i]
+                    let childLeft = i === 0 && (col.children.length > 1 || leftBorder)
+                    let childRight = i === col.children.length - 1 && (col.children.length > 1 || rightBorder)
+                    let childSize = this.computeRenderDataRec(cols, child, childPos, depth + 1, result, childLeft, childRight)
+                    childPos += childSize
+                    size += childSize
+                }
+            } else {
+                for (let i = depth + 1; i < result.length; i++)
+                    result[i].push({id: colId, span: 1, leftBd: leftBorder, rightBd: rightBorder, empty: true})
+                size = 1
+            }
+            let left = leftBorder
+            let right = rightBorder
+            if (size > 1) {
+                left = true
+                right = true
+            }
+            result[depth].push({id: colId, span: size, leftBd: left, rightBd: right})
+            return size
+        }
+
+        this.getTableElement = function (id) {
+            return document.getElementById("df_" + id)
+        }
+
+        this.getTableData = function (id) {
+            return this.getTableElement(id).df
+        }
+
+        this.createExpander = function (isExpanded) {
+            const svgNs = "http://www.w3.org/2000/svg"
+            let svg = document.createElementNS(svgNs, "svg")
+            svg.classList.add("expanderSvg")
+            let path = document.createElementNS(svgNs, "path")
+            if (isExpanded) {
+                svg.setAttribute("viewBox", "0 -2 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 4 4 4 -4 -1 -1 -3 3Z")
+            } else {
+                svg.setAttribute("viewBox", "-2 0 8 8")
+                path.setAttribute("d", "M1 0 l-1 1 3 3 -3 3 1 1 4 -4Z")
+            }
+            path.setAttribute("fill", "currentColor")
+            svg.appendChild(path)
+            return svg
+        }
+
+        this.renderTable = function (id) {
+
+            let table = this.getTableElement(id)
+
+            if (table === null) return
+
+            table.innerHTML = ""
+
+            let df = table.df
+            let rootDf = df.rootId === df.id ? df : this.getTableData(df.rootId)
+
+            // header
+            let header = document.createElement("thead")
+            table.appendChild(header)
+
+            let renderData = this.computeRenderData(df)
+            for (let j = 0; j < renderData.length; j++) {
+                let rowData = renderData[j]
+                let tr = document.createElement("tr");
+                let isLastRow = j === renderData.length - 1
+                header.appendChild(tr);
+                for (let i = 0; i < rowData.length; i++) {
+                    let cell = rowData[i]
+                    let th = document.createElement("th");
+                    th.setAttribute("colspan", cell.span)
+                    let colId = cell.id
+                    let col = df.cols[colId];
+                    if (!cell.empty) {
+                        if (col.children.length === 0) {
+                            th.innerHTML = col.name
+                        } else {
+                            let link = document.createElement("a")
+                            link.className = "expander"
+                            let that = this
+                            link.onclick = function () {
+                                col.expanded = !col.expanded
+                                that.renderTable(id)
+                            }
+                            link.appendChild(this.createExpander(col.expanded))
+                            link.innerHTML += col.name
+                            th.appendChild(link)
+                        }
+                    }
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (isLastRow)
+                        classes += " bottomBorder"
+                    if (classes.length > 0)
+                        th.setAttribute("class", classes)
+                    tr.appendChild(th)
+                }
+            }
+
+            // body
+            let body = document.createElement("tbody")
+            table.appendChild(body)
+
+            let columns = renderData.pop()
+            for (let row = 0; row < df.nrow; row++) {
+                let tr = document.createElement("tr");
+                body.appendChild(tr)
+                for (let i = 0; i < columns.length; i++) {
+                    let cell = columns[i]
+                    let td = document.createElement("td");
+                    let colId = cell.id
+                    let col = df.cols[colId]
+                    let classes = (cell.leftBd ? " leftBorder" : "") + (cell.rightBd ? " rightBorder" : "")
+                    if (col.rightAlign)
+                        classes += " rightAlign"
+                    if (classes.length > 0)
+                        td.setAttribute("class", classes)
+                    tr.appendChild(td)
+                    let value = col.values[row]
+                    if (value.frameId !== undefined) {
+                        let frameId = value.frameId
+                        let expanded = rootDf.expandedFrames.has(frameId)
+                        let link = document.createElement("a")
+                        link.className = "expander"
+                        let that = this
+                        link.onclick = function () {
+                            if (rootDf.expandedFrames.has(frameId))
+                                rootDf.expandedFrames.delete(frameId)
+                            else rootDf.expandedFrames.add(frameId)
+                            that.renderTable(id)
+                        }
+                        link.appendChild(this.createExpander(expanded))
+                        link.innerHTML += value.value
+                        if (expanded) {
+                            td.appendChild(link)
+                            td.appendChild(document.createElement("p"))
+                            const childTable = document.createElement("table")
+                            childTable.className = "dataframe"
+                            childTable.id = "df_" + frameId
+                            let childDf = rootDf.childFrames[frameId]
+                            childTable.df = childDf
+                            td.appendChild(childTable)
+                            this.renderTable(frameId)
+                            if (childDf.nrow !== childDf.totalRows) {
+                                const footer = document.createElement("p")
+                                footer.innerText = `... showing only top ${childDf.nrow} of ${childDf.totalRows} rows`
+                                td.appendChild(footer)
+                            }
+                        } else {
+                            td.appendChild(link)
+                        }
+                    } else if (value.style !== undefined) {
+                        td.innerHTML = value.value
+                        td.setAttribute("style", value.style)
+                    } else td.innerHTML = value
+                    this.nodeScriptReplace(td)
+                }
+            }
+        }
+
+        this.nodeScriptReplace = function (node) {
+            if (this.nodeScriptIs(node) === true) {
+                node.parentNode.replaceChild(this.nodeScriptClone(node), node);
+            } else {
+                let i = -1, children = node.childNodes;
+                while (++i < children.length) {
+                    this.nodeScriptReplace(children[i]);
+                }
+            }
+
+            return node;
+        }
+
+        this.nodeScriptClone = function (node) {
+            let script = document.createElement("script");
+            script.text = node.innerHTML;
+
+            let i = -1, attrs = node.attributes, attr;
+            while (++i < attrs.length) {
+                script.setAttribute((attr = attrs[i]).name, attr.value);
+            }
+            return script;
+        }
+
+        this.nodeScriptIs = function (node) {
+            return node.tagName === 'SCRIPT';
+        }
+    })()
+
+    window.call_DataFrame = function (f) {
+        return f();
+    };
+
+    let funQueue = window["kotlinQueues"] && window["kotlinQueues"]["DataFrame"];
+    if (funQueue) {
+        funQueue.forEach(function (f) {
+            f();
+        });
+        funQueue = [];
+    }
+})()
+
+/*<!--*/
+call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"city: String?\">city</span>", children: [], rightAlign: false, values: ["London","Dubai","Moscow","Milan","Tokyo","<span class=\"formatted\" title=\"\"><span class=\"null\">null</span></span>"] }, 
+{ name: "<span title=\"countDistinct: Int\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">countDistinct</span>", children: [], rightAlign: true, values: ["<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">2</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>","<span class=\"formatted\" title=\"\"><span class=\"numbers\">1</span></span>"] }, 
+], id: 0, rootId: 0, totalRows: 6 } ) });
+/*-->*/
+
+call_DataFrame(function() { DataFrame.renderTable(0) });
+
+function sendHeight() {
+    const table = document.querySelector('table.dataframe');
+    if (!table) return;
+
+    let height = 0;
+    
+    const thead = table.querySelector('thead');
+    if (thead) height += thead.offsetHeight;
+    
+    const rows = table.querySelectorAll(':scope > tbody > tr');
+    rows.forEach(row => {
+        height += row.offsetHeight;
+    });
+    
+    height += getVerticalMargins(table) + 10;
+
+    window.parent.postMessage({ type: 'iframeHeight', height: Math.ceil(height) }, '*');
+}
+
+function getVerticalMargins(element) {
+    const style = getComputedStyle(element);
+    return parseFloat(style.marginTop) + parseFloat(style.marginBottom);
+}
+
+function repeatHeightCalculation(maxRetries = 10, interval = 100) {
+    let retries = 0;
+    const intervalId = setInterval(() => {
+        sendHeight();
+        retries++;
+        if (retries >= maxRetries) clearInterval(intervalId);
+    }, interval);
+}
+
+window.addEventListener('load', repeatHeightCalculation);
+
+const observer = new MutationObserver(() => repeatHeightCalculation(5, 50));
+observer.observe(document.querySelector('.dataframe'), {
+    childList: true,
+    subtree: true,
+    characterData: true,
+});
+
+
+</script>
+</html>
diff --git a/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html b/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
index 49beb58089..8ff674999f 100644
--- a/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
+++ b/docs/StardustDocs/resources/api/pivot/pivotInward_properties.html
@@ -459,7 +459,7 @@
 /*<!--*/
 call_DataFrame(function() { DataFrame.addTable({ cols: [{ name: "<span title=\"true: api.FormattedFrame<Any?>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">true</span>", children: [], rightAlign: false, values: [{ frameId: 1, value: "<b>DataFrame 5 x 5</b>" }] }, 
 { name: "<span title=\"false: api.FormattedFrame<Any?>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">false</span>", children: [], rightAlign: false, values: [{ frameId: 2, value: "<b>DataFrame 5 x 5</b>" }] }, 
-{ name: "<span title=\"isHappy: DataRow<*>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">isHappy</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"true: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@168b4cb0\nfalse: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@23da79eb\"><span class=\"structural\">{ </span><span class=\"structural\">true: </span>org.jetbrains.kotlinx<span class=\"structural\">...</span><span class=\"structural\">, </span><span class=\"structural\">f...</span><span class=\"structural\"> }</span></span>"] }, 
+{ name: "<span title=\"isHappy: DataRow<*>\" style=\"color:#f44336;font-family:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace\">isHappy</span>", children: [0, 1], rightAlign: false, values: ["<span class=\"formatted\" title=\"true: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@523a7801\nfalse: org.jetbrains.kotlinx.dataframe.api.FormattedFrame@1f736d00\"><span class=\"structural\">{ </span><span class=\"structural\">true: </span>org.jetbrains.kotlinx<span class=\"structural\">...</span><span class=\"structural\">, </span><span class=\"structural\">f...</span><span class=\"structural\"> }</span></span>"] }, 
 ], id: 0, rootId: 0, totalRows: 1 } ) });
 /*-->*/
 
diff --git a/docs/StardustDocs/topics/_shadow_resources.md b/docs/StardustDocs/topics/_shadow_resources.md
index c9a1d3b506..e000fc5e0e 100644
--- a/docs/StardustDocs/topics/_shadow_resources.md
+++ b/docs/StardustDocs/topics/_shadow_resources.md
@@ -202,6 +202,7 @@
 <resource src="valuesOnGroupBySelectedColumns_properties.html"></resource>
 <resource src="valuesOnGroupByRenameColumns_properties.html"></resource>
 <resource src="countOnGroupBy_properties.html"></resource>
+<resource src="countDistinctOnGroupBy_properties.html"></resource>
 <resource src="aggregateOnGroupBy_properties.html"></resource>
 <resource src="aggregateOnGroupByWithoutInto_properties.html"></resource>
 <resource src="maxOnGroupBy_properties.html"></resource>
@@ -318,3 +319,10 @@
 <resource src="dateTimeSample.html"></resource>
 <resource src="readDatesWithSpecificDateTimePattern.html"></resource>
 <resource src="readDatesWithSpecificDateTimeFormatter.html"></resource>
+<resource src="countDistinctDf.html"></resource>
+<resource src="countDistinctColumnsDf.html"></resource>
+<resource src="countDistinctOnGroupBySmallTable_properties.html"></resource>
+<resource src="countDistinctGroupBy.html"></resource>
+<resource src="countDistinctColumnsOnGroupBy_properties.html"></resource>
+<resource src="countDistinctColumnsCustomNameOnGroupBy_properties.html"></resource>
+<resource src="countDistinctColumnsGroupBy.html"></resource>
diff --git a/docs/StardustDocs/topics/countDistinct.md b/docs/StardustDocs/topics/countDistinct.md
index 5c2a406761..b1b01039c6 100644
--- a/docs/StardustDocs/topics/countDistinct.md
+++ b/docs/StardustDocs/topics/countDistinct.md
@@ -1,33 +1,129 @@
 [//]: # (title: countDistinct)
 
-<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.Access-->
+<!---IMPORT org.jetbrains.kotlinx.dataframe.samples.api.CountDistinctSamples-->
 
-Returns number of distinct combinations of values in selected columns of [`DataFrame`](DataFrame.md).
+
+Counts distinct rows or distinct combinations of values in selected columns.
+
+When `countDistinct` is used on a [`DataFrame`](DataFrame.md), 
+it returns the number of distinct rows in this [`DataFrame`](DataFrame.md).
+
+<!---FUN countDistinctDf-->
+
+```kotlin
+df
+```
+
+<!---END-->
+<inline-frame src="./resources/countDistinctDf.html" width="100%" height="500px"></inline-frame>
+
+<!---FUN countDistinct-->
+
+```kotlin
+df.countDistinct() // the result is 4
+```
+
+<!---END-->
+
+You can also specify which columns to use when counting distinct combinations of values.
+
+<inline-frame src="./resources/countDistinctColumnsDf.html" width="100%" height="500px"></inline-frame>
 
 <!---FUN countDistinctColumns-->
 <tabs>
 <tab title="Properties">
 
 ```kotlin
-df.countDistinct { age and name }
+df.countDistinct { name.firstName and city } // the result is 3
 ```
 
 </tab>
 <tab title="Strings">
 
 ```kotlin
-df.countDistinct("age", "name")
+df.countDistinct { "name"["firstName"] and "city" } // the result is 3
 ```
 
 </tab></tabs>
 <!---END-->
 
-When `columns` are not specified, returns number of distinct rows in [`DataFrame`](DataFrame.md).
+When `countDistinct` is used on a `GroupBy`, it counts distinct rows within each group.
+That is, this function returns a [`DataFrame`](DataFrame.md) where each row corresponds to a group 
+from the original `GroupBy`. The result contains the original group key columns 
+and a new column with the number of distinct rows (or combinations of values in selected columns) in each group.
 
-<!---FUN countDistinct-->
+Let's take this `GroupBy` as an example:
+
+<!---FUN countDistinctGroupBy-->
+
+```kotlin
+df.groupBy { city }
+```
+
+<!---END-->
+<inline-frame src="./resources/countDistinctGroupBy.html" width="100%" height="500px"></inline-frame>
+
+Applying `countDistinct` to this `GroupBy` yields the following result:
+
+<!---FUN countDistinctOnGroupBy-->
+<tabs>
+<tab title="Properties">
+
+```kotlin
+df.groupBy { city }.countDistinct()
+```
+
+</tab>
+<tab title="Strings">
 
 ```kotlin
-df.countDistinct()
+df.groupBy("city").countDistinct()
 ```
 
+</tab></tabs>
+<!---END-->
+<inline-frame src="./resources/countDistinctOnGroupBySmallTable_properties.html" width="100%" height="500px"></inline-frame>
+
+You can also specify which columns in the groups should be used to determine distinctness.
+
+<inline-frame src="./resources/countDistinctColumnsGroupBy.html" width="100%" height="500px"></inline-frame>
+
+<!---FUN countDistinctColumnsOnGroupBy-->
+<tabs>
+<tab title="Properties">
+
+```kotlin
+df.groupBy { city }.countDistinct { name.firstName }
+```
+
+</tab>
+<tab title="Strings">
+
+```kotlin
+df.groupBy("city").countDistinct { "name"["firstName"] }
+```
+
+</tab></tabs>
+<!---END-->
+<inline-frame src="./resources/countDistinctColumnsOnGroupBy_properties.html" width="100%" height="500px"></inline-frame>
+
+The default name of the new column is `countDistinct`, but you can choose a different one.
+
+<!---FUN countDistinctColumnsCustomNameOnGroupBy-->
+<tabs>
+<tab title="Properties">
+
+```kotlin
+df.groupBy { city }.countDistinct("uniqueFirstNames") { name.firstName }
+```
+
+</tab>
+<tab title="Strings">
+
+```kotlin
+df.groupBy("city").countDistinct("uniqueFirstNames") { "name"["firstName"] }
+```
+
+</tab></tabs>
 <!---END-->
+<inline-frame src="./resources/countDistinctColumnsCustomNameOnGroupBy_properties.html" width="100%" height="500px"></inline-frame>
diff --git a/docs/StardustDocs/topics/groupBy.md b/docs/StardustDocs/topics/groupBy.md
index b710b53e81..122fa8ace0 100644
--- a/docs/StardustDocs/topics/groupBy.md
+++ b/docs/StardustDocs/topics/groupBy.md
@@ -23,7 +23,7 @@ transformations = [ .sortByGroup { expression } | .sortByGroupDesc { expression
 reducer = .minBy { column } | .maxBy { column } | .medianBy { rowExpression } | .percentileBy(percentile) { rowExpression } | .first [ { rowCondition } ] | .last [ { rowCondition } ] 
           .concat() | .into([column]) [{ rowExpression }] | .values { valueColumns } 
 
-aggregator = .count() | .concat() | .concatWithKeys() | .toDataFrame() | .into([column]) [{ rowExpression }] | .values { valueColumns } | .aggregate { aggregations } | .<stat> [ { columns } ]
+aggregator = .count() | .countDistinct() | .concat() | .concatWithKeys() | .toDataFrame() | .into([column]) [{ rowExpression }] | .values { valueColumns } | .aggregate { aggregations } | .<stat> [ { columns } ]
 
 pivot = .pivot { columns }
       [ .default(defaultValue) ]
@@ -602,22 +602,35 @@ A `GroupBy` can be directly transformed into a new [`DataFrame`](DataFrame.md) b
 Aggregation is a generalization of [`reducing`](groupBy.md#reducing).
 
 The following aggregation methods are available:
-* [`concat`](concat.md) — concatenates all [`rows`](DataRow.md) from all groups into a single [`DataFrame`](DataFrame.md), without preserving grouping keys.
-* [`toDataFrame`](createDataFrame.md#todataframe) — returns this `GroupBy` as a [`DataFrame`](DataFrame.md) with the grouping keys and corresponding groups in [FrameColumn](DataColumn.md#framecolumn).
-* `concatWithKeys` — a variant of [`concat`](concat.md) that also includes grouping keys that were not present in the original [`DataFrame`](DataFrame.md).
-* `into` — creates a new [`column`](DataColumn.md) containing a list of values computed with a `RowExpression` for each group, or a new [FrameColumn](DataColumn.md#framecolumn) containing the groups themselves.
-* [`values`](values.md) — collects all column values for every group without aggregation. For a [ValueColumn](DataColumn.md#valuecolumn) of type `T` it will gather group values into lists of type `List<T>`.
-For a [ColumnGroup](DataColumn.md#columngroup) it will gather group values into a [`DataFrame`](DataFrame.md) and convert that [ColumnGroup](DataColumn.md#columngroup) into a [FrameColumn](DataColumn.md#framecolumn).
-* [`count`](count.md) — creates a [`DataFrame`](DataFrame.md) containing the grouping key columns and an additional [`column`](DataColumn.md) with the number of rows in each corresponding group.
-* `aggregate` — performs a set of custom aggregations using `AggregateDsl`, allowing you to compute one or more [statistics](summaryStatistics.md) per every group of `GroupBy`. 
-The body if this function will be executed for every data group and has a receiver of type [`DataFrame`](DataFrame.md) that represents the current data group being aggregated. 
+* [`concat`](concat.md) — concatenates all [`rows`](DataRow.md) from all groups into a single [`DataFrame`](DataFrame.md), 
+without preserving grouping keys.
+* [`toDataFrame`](createDataFrame.md#todataframe) — returns this `GroupBy` as a [`DataFrame`](DataFrame.md) 
+with the grouping keys and corresponding groups in [FrameColumn](DataColumn.md#framecolumn).
+* `concatWithKeys` — a variant of [`concat`](concat.md) 
+that also includes grouping keys that were not present in the original [`DataFrame`](DataFrame.md).
+* `into` — creates a new [`column`](DataColumn.md) containing a list of values computed with a `RowExpression` for each group, 
+or a new [FrameColumn](DataColumn.md#framecolumn) containing the groups themselves.
+* [`values`](values.md) — collects all column values for every group without aggregation. 
+For a [ValueColumn](DataColumn.md#valuecolumn) of type `T` it will gather group values into lists of type `List<T>`.
+For a [ColumnGroup](DataColumn.md#columngroup) it will gather group values into a [`DataFrame`](DataFrame.md) 
+and convert that [ColumnGroup](DataColumn.md#columngroup) into a [FrameColumn](DataColumn.md#framecolumn).
+* [`count`](count.md) — creates a [`DataFrame`](DataFrame.md) containing the grouping key columns 
+and an additional [`column`](DataColumn.md) with the number of rows in each corresponding group.
+* [`countDistinct`](countDistinct.md) — creates a [`DataFrame`](DataFrame.md) containing the grouping key columns 
+and an additional [`column`](DataColumn.md) with the number of distinct rows in each corresponding group.
+* `aggregate` — performs a set of custom aggregations using `AggregateDsl`, 
+allowing you to compute one or more [statistics](summaryStatistics.md) per every group of `GroupBy`. 
+The body if this function will be executed for every data group and has a receiver of type [`DataFrame`](DataFrame.md) 
+that represents the current data group being aggregated. 
 To add a new column to the resulting [`DataFrame`](DataFrame.md), pass the name of the new column to infix function `into`.
 
-Each of these methods returns a new DataFrame that includes the grouping key columns (except for [`concat`](concat.md)) along with the columns of values aggregated from the corresponding groups.
+Each of these methods returns a new DataFrame that includes the grouping key columns (except for [`concat`](concat.md)) 
+along with the columns of values aggregated from the corresponding groups.
 
 ### Examples of aggregation
 #### concat on GroupBy {collapsible="true"}
-[`concat`](concat.md) can be used to union all data groups of `GroupBy` into the original [`DataFrame`](DataFrame.md) preserving the new order of rows produced by grouping:
+[`concat`](concat.md) can be used to union all data groups of `GroupBy` into the original [`DataFrame`](DataFrame.md) 
+preserving the new order of rows produced by grouping:
 
 <!---FUN concatOnGroupBy-->
 <tabs>
@@ -781,6 +794,26 @@ df.groupBy("city").count()
 <!---END-->
 <inline-frame src="resources/countOnGroupBy_properties.html" width="100%"/>
 
+#### countDistinct on GroupBy {collapsible="true"}
+<!---FUN countDistinctOnGroupBy-->
+<tabs>
+<tab title="Properties">
+
+```kotlin
+df.groupBy { city }.countDistinct { name.firstName }
+```
+
+</tab>
+<tab title="Strings">
+
+```kotlin
+df.groupBy("city").countDistinct { "name"["firstName"] }
+```
+
+</tab></tabs>
+<!---END-->
+<inline-frame src="./resources/countDistinctOnGroupBy_properties.html" width="100%" height="500px"></inline-frame>
+
 #### aggregate on GroupBy {collapsible="true"}
 <!---FUN aggregateOnGroupBy-->
 <tabs>
@@ -849,6 +882,7 @@ Each function computes a statistic across the [`rows`](DataRow.md) of a group an
 
 The following aggregation statistics are available:
 * [`count`](count.md);
+* [`countDistinct`](countDistinct.md);
 * [`max / maxOf / maxFor`](minmax.md); 
 * [`min / minOf / minFor`](minmax.md); 
 * [`sum / sumOf / sumFor`](sum.md); 
diff --git a/samples/build.gradle.kts b/samples/build.gradle.kts
index 5e3051ad85..7269a5e63b 100644
--- a/samples/build.gradle.kts
+++ b/samples/build.gradle.kts
@@ -114,6 +114,7 @@ korro {
                 include("columnArithmetics.md")
                 include("groupBy.md")
                 include("pivot.md")
+                include("countDistinct.md")
             },
         )
         baseDir = rootProject.file("docs/StardustDocs/topics")
diff --git a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/DataFrameSampleHelper.kt b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/DataFrameSampleHelper.kt
index 8b63791f9a..620d9a1a6d 100644
--- a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/DataFrameSampleHelper.kt
+++ b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/DataFrameSampleHelper.kt
@@ -1,8 +1,13 @@
 package org.jetbrains.kotlinx.dataframe.samples
 
 import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.api.CodeString
+import org.jetbrains.kotlinx.dataframe.api.GroupBy
 import org.jetbrains.kotlinx.dataframe.api.toDataFrame
+import org.jetbrains.kotlinx.dataframe.io.DataFrameHtmlData
+import org.jetbrains.kotlinx.dataframe.io.DisplayConfiguration
+import org.jetbrains.kotlinx.dataframe.io.toStandaloneHtml
 import org.jetbrains.kotlinx.dataframe.samples.api.TestBase
 import org.jetbrains.kotlinx.kandy.letsplot.samples.SampleHelper
 import java.io.File
@@ -44,4 +49,49 @@ abstract class DataFrameSampleHelper(sampleName: String, subFolder: String = "sa
     fun DataColumn<*>.saveDfHtmlSample() {
         toDataFrame().saveDfHtmlSample()
     }
+
+    // TODO: might be changed as #1887 is fixed
+    private val expandNestedFramesScript = DataFrameHtmlData(
+        script =
+            """
+            (function () {
+                function expandColumnGroups(df) {
+                    for (let col of df.cols) {
+                        if (col.parent === undefined && col.children.length > 0) col.expanded = true;
+                    }
+                }
+
+                function expandNestedFrames(df, rootDf) {
+                    for (let col of df.cols) {
+                        for (let value of col.values) {
+                            if (value && value.frameId !== undefined) {
+                                rootDf.expandedFrames.add(value.frameId);
+                                let child = rootDf.childFrames[value.frameId];
+                                if (child) {
+                                    expandColumnGroups(child);
+                                    expandNestedFrames(child, rootDf);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                document.querySelectorAll("table.dataframe").forEach(function (table) {
+                    if (table.df && table.df.id === table.df.rootId) {
+                        let rootDf = table.df;
+                        expandNestedFrames(rootDf, rootDf);
+                        DataFrame.renderTable(rootDf.id);
+                    }
+                });
+            })();
+            """.trimIndent(),
+    )
+
+    fun DataFrame<*>.toHtmlWithOpenedNestedDfs() =
+        toStandaloneHtml(
+            configuration = DisplayConfiguration(enableFallbackStaticTables = false),
+            getFooter = { "" },
+        ) + expandNestedFramesScript
+
+    fun GroupBy<*, *>.toHtmlWithOpenedNestedDfs() = toDataFrame().toHtmlWithOpenedNestedDfs()
 }
diff --git a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/CountDistinctSamples.kt b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/CountDistinctSamples.kt
new file mode 100644
index 0000000000..377984cb36
--- /dev/null
+++ b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/CountDistinctSamples.kt
@@ -0,0 +1,137 @@
+package org.jetbrains.kotlinx.dataframe.samples.api
+
+import org.jetbrains.kotlinx.dataframe.api.RgbColor
+import org.jetbrains.kotlinx.dataframe.api.and
+import org.jetbrains.kotlinx.dataframe.api.convert
+import org.jetbrains.kotlinx.dataframe.api.countDistinct
+import org.jetbrains.kotlinx.dataframe.api.filter
+import org.jetbrains.kotlinx.dataframe.api.format
+import org.jetbrains.kotlinx.dataframe.api.groupBy
+import org.jetbrains.kotlinx.dataframe.api.perRowCol
+import org.jetbrains.kotlinx.dataframe.api.take
+import org.jetbrains.kotlinx.dataframe.api.with
+import org.jetbrains.kotlinx.dataframe.samples.DataFrameSampleHelper
+import org.jetbrains.kotlinx.dataframe.util.defaultHeaderFormatting
+import org.junit.Test
+
+class CountDistinctSamples : DataFrameSampleHelper("countDistinct", "api") {
+    val df = peopleDf.take(7).filter { index() in setOf(0, 1, 2, 6) }
+
+    private fun firstNameToColor(name: String): RgbColor =
+        when (name) {
+            "Alice" -> RgbColor(189, 206, 233)
+            "Bob" -> RgbColor(198, 224, 198)
+            "Charlie" -> RgbColor(219, 198, 230)
+            else -> RgbColor(255, 255, 255)
+        }
+
+    @Test
+    fun countDistinctDf() {
+        // SampleStart
+        df
+            // SampleEnd
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinct() {
+        // SampleStart
+        df.countDistinct() // the result is 4
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumns_properties() {
+        // SampleStart
+        df.countDistinct { name.firstName and city } // the result is 3
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumns_strings() {
+        // SampleStart
+        df.countDistinct { "name"["firstName"] and "city" } // the result is 3
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumnsDf() {
+        df.format().perRowCol { row, _ ->
+            val firstName = df[row.index()].name.firstName
+            background(firstNameToColor(firstName)) and textColor(black)
+        }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctGroupBy() {
+        // SampleStart
+        df.groupBy { city }
+            // SampleEnd
+            .toHtmlWithOpenedNestedDfs()
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctOnGroupBySmallTable_properties() {
+        // SampleStart
+        df.groupBy { city }.countDistinct()
+            // SampleEnd
+            .defaultHeaderFormatting { "countDistinct"() }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctOnGroupBySmallTable_strings() {
+        // SampleStart
+        df.groupBy("city").countDistinct()
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumnsOnGroupBy_properties() {
+        // SampleStart
+        df.groupBy { city }.countDistinct { name.firstName }
+            // SampleEnd
+            .defaultHeaderFormatting { "countDistinct"() }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctColumnsOnGroupBy_strings() {
+        // SampleStart
+        df.groupBy("city").countDistinct { "name"["firstName"] }
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumnsCustomNameOnGroupBy_properties() {
+        // SampleStart
+        df.groupBy { city }.countDistinct("uniqueFirstNames") { name.firstName }
+            // SampleEnd
+            .defaultHeaderFormatting { "uniqueFirstNames"() }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctColumnsCustomNameOnGroupBy_strings() {
+        // SampleStart
+        df.groupBy("city").countDistinct("uniqueFirstNames") { "name"["firstName"] }
+        // SampleEnd
+    }
+
+    @Test
+    fun countDistinctColumnsGroupBy() {
+        df.groupBy { city }
+            .toDataFrame()
+            .convert { group }.with { group ->
+                val firstNameCol = group["name"]["firstName"]
+                group.format().perRowCol { row, _ ->
+                    val firstName = firstNameCol[row.index()] as String
+                    background(firstNameToColor(firstName)) and textColor(black)
+                }
+            }
+            .toHtmlWithOpenedNestedDfs()
+            .saveDfHtmlSample()
+    }
+}
diff --git a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/GroupBySamples.kt b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/GroupBySamples.kt
index bde4d02289..59f4f0372e 100644
--- a/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/GroupBySamples.kt
+++ b/samples/src/test/kotlin/org/jetbrains/kotlinx/dataframe/samples/api/GroupBySamples.kt
@@ -12,6 +12,7 @@ import org.jetbrains.kotlinx.dataframe.api.concat
 import org.jetbrains.kotlinx.dataframe.api.concatWithKeys
 import org.jetbrains.kotlinx.dataframe.api.convert
 import org.jetbrains.kotlinx.dataframe.api.count
+import org.jetbrains.kotlinx.dataframe.api.countDistinct
 import org.jetbrains.kotlinx.dataframe.api.dataFrameOf
 import org.jetbrains.kotlinx.dataframe.api.div
 import org.jetbrains.kotlinx.dataframe.api.expr
@@ -661,6 +662,22 @@ class GroupBySamples : DataFrameSampleHelper("groupBy", "api") {
         // SampleEnd
     }
 
+    @Test
+    fun countDistinctOnGroupBy_properties() {
+        // SampleStart
+        df.groupBy { city }.countDistinct { name.firstName }
+            // SampleEnd
+            .defaultHeaderFormatting { "countDistinct"() }
+            .saveDfHtmlSample()
+    }
+
+    @Test
+    fun countDistinctOnGroupBy_strings() {
+        // SampleStart
+        df.groupBy("city").countDistinct { "name"["firstName"] }
+        // SampleEnd
+    }
+
     @Test
     fun aggregateOnGroupBy_properties() {
         // SampleStart